deploy: v0.12 fix 存档key名

node_modules/react-error-boundary/dist/index.d.ts

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

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

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

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

@@ -0,0 +1,171 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _inheritsLoose = require('@babel/runtime/helpers/inheritsLoose');
+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 changedArray(a, b) {
+  if (a === void 0) {
+    a = [];
+  }
+
+  if (b === void 0) {
+    b = [];
+  }
+
+  return a.length !== b.length || a.some(function (item, index) {
+    return !Object.is(item, b[index]);
+  });
+};
+
+var initialState = {
+  error: null
+};
+
+var ErrorBoundary = /*#__PURE__*/function (_React$Component) {
+  _inheritsLoose__default["default"](ErrorBoundary, _React$Component);
+
+  function ErrorBoundary() {
+    var _this;
+
+    for (var _len = arguments.length, _args = new Array(_len), _key = 0; _key < _len; _key++) {
+      _args[_key] = arguments[_key];
+    }
+
+    _this = _React$Component.call.apply(_React$Component, [this].concat(_args)) || this;
+    _this.state = initialState;
+
+    _this.resetErrorBoundary = function () {
+      var _this$props;
+
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+
+      _this.props.onReset == null ? void 0 : (_this$props = _this.props).onReset.apply(_this$props, args);
+
+      _this.reset();
+    };
+
+    return _this;
+  }
+
+  ErrorBoundary.getDerivedStateFromError = function getDerivedStateFromError(error) {
+    return {
+      error: error
+    };
+  };
+
+  var _proto = ErrorBoundary.prototype;
+
+  _proto.reset = function reset() {
+    this.setState(initialState);
+  };
+
+  _proto.componentDidCatch = function componentDidCatch(error, info) {
+    var _this$props$onError, _this$props2;
+
+    (_this$props$onError = (_this$props2 = this.props).onError) == null ? void 0 : _this$props$onError.call(_this$props2, error, info);
+  };
+
+  _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
+    // the error boundary immediately. This would likely trigger a second
+    // error to be thrown.
+    // 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 && 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);
+      this.reset();
+    }
+  };
+
+  _proto.render = function render() {
+    var error = this.state.error;
+    var _this$props4 = this.props,
+        fallbackRender = _this$props4.fallbackRender,
+        FallbackComponent = _this$props4.FallbackComponent,
+        fallback = _this$props4.fallback;
+
+    if (error !== null) {
+      var _props = {
+        error: error,
+        resetErrorBoundary: this.resetErrorBoundary
+      };
+
+      if ( /*#__PURE__*/React__namespace.isValidElement(fallback)) {
+        return fallback;
+      } else if (typeof fallbackRender === 'function') {
+        return fallbackRender(_props);
+      } else if (FallbackComponent) {
+        return /*#__PURE__*/React__namespace.createElement(FallbackComponent, _props);
+      } else {
+        throw new Error('react-error-boundary requires either a fallback, fallbackRender, or FallbackComponent prop');
+      }
+    }
+
+    return this.props.children;
+  };
+
+  return ErrorBoundary;
+}(React__namespace.Component);
+
+function withErrorBoundary(Component, errorBoundaryProps) {
+  var Wrapped = function Wrapped(props) {
+    return /*#__PURE__*/React__namespace.createElement(ErrorBoundary, errorBoundaryProps, /*#__PURE__*/React__namespace.createElement(Component, props));
+  }; // Format for display in DevTools
+
+
+  var name = Component.displayName || Component.name || 'Unknown';
+  Wrapped.displayName = "withErrorBoundary(" + name + ")";
+  return Wrapped;
+}
+
+function useErrorHandler(givenError) {
+  var _React$useState = React__namespace.useState(null),
+      error = _React$useState[0],
+      setError = _React$useState[1];
+
+  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"
+*/
+
+exports.ErrorBoundary = ErrorBoundary;
+exports.useErrorHandler = useErrorHandler;
+exports.withErrorBoundary = withErrorBoundary;

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

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

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

@@ -0,0 +1,142 @@
+import _inheritsLoose from '@babel/runtime/helpers/esm/inheritsLoose';
+import * as React from 'react';
+
+var changedArray = function changedArray(a, b) {
+  if (a === void 0) {
+    a = [];
+  }
+
+  if (b === void 0) {
+    b = [];
+  }
+
+  return a.length !== b.length || a.some(function (item, index) {
+    return !Object.is(item, b[index]);
+  });
+};
+
+var initialState = {
+  error: null
+};
+
+var ErrorBoundary = /*#__PURE__*/function (_React$Component) {
+  _inheritsLoose(ErrorBoundary, _React$Component);
+
+  function ErrorBoundary() {
+    var _this;
+
+    for (var _len = arguments.length, _args = new Array(_len), _key = 0; _key < _len; _key++) {
+      _args[_key] = arguments[_key];
+    }
+
+    _this = _React$Component.call.apply(_React$Component, [this].concat(_args)) || this;
+    _this.state = initialState;
+
+    _this.resetErrorBoundary = function () {
+      var _this$props;
+
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+
+      _this.props.onReset == null ? void 0 : (_this$props = _this.props).onReset.apply(_this$props, args);
+
+      _this.reset();
+    };
+
+    return _this;
+  }
+
+  ErrorBoundary.getDerivedStateFromError = function getDerivedStateFromError(error) {
+    return {
+      error: error
+    };
+  };
+
+  var _proto = ErrorBoundary.prototype;
+
+  _proto.reset = function reset() {
+    this.setState(initialState);
+  };
+
+  _proto.componentDidCatch = function componentDidCatch(error, info) {
+    var _this$props$onError, _this$props2;
+
+    (_this$props$onError = (_this$props2 = this.props).onError) == null ? void 0 : _this$props$onError.call(_this$props2, error, info);
+  };
+
+  _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
+    // the error boundary immediately. This would likely trigger a second
+    // error to be thrown.
+    // 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 && 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);
+      this.reset();
+    }
+  };
+
+  _proto.render = function render() {
+    var error = this.state.error;
+    var _this$props4 = this.props,
+        fallbackRender = _this$props4.fallbackRender,
+        FallbackComponent = _this$props4.FallbackComponent,
+        fallback = _this$props4.fallback;
+
+    if (error !== null) {
+      var _props = {
+        error: error,
+        resetErrorBoundary: this.resetErrorBoundary
+      };
+
+      if ( /*#__PURE__*/React.isValidElement(fallback)) {
+        return fallback;
+      } else if (typeof fallbackRender === 'function') {
+        return fallbackRender(_props);
+      } else if (FallbackComponent) {
+        return /*#__PURE__*/React.createElement(FallbackComponent, _props);
+      } else {
+        throw new Error('react-error-boundary requires either a fallback, fallbackRender, or FallbackComponent prop');
+      }
+    }
+
+    return this.props.children;
+  };
+
+  return ErrorBoundary;
+}(React.Component);
+
+function withErrorBoundary(Component, errorBoundaryProps) {
+  var Wrapped = function Wrapped(props) {
+    return /*#__PURE__*/React.createElement(ErrorBoundary, errorBoundaryProps, /*#__PURE__*/React.createElement(Component, props));
+  }; // Format for display in DevTools
+
+
+  var name = Component.displayName || Component.name || 'Unknown';
+  Wrapped.displayName = "withErrorBoundary(" + name + ")";
+  return Wrapped;
+}
+
+function useErrorHandler(givenError) {
+  var _React$useState = React.useState(null),
+      error = _React$useState[0],
+      setError = _React$useState[1];
+
+  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"
+*/
+
+export { ErrorBoundary, useErrorHandler, withErrorBoundary };

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

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

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

@@ -0,0 +1,187 @@
+(function (global, factory) {
+  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';
+
+  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;
+    _setPrototypeOf(subClass, superClass);
+  }
+
+  var changedArray = function changedArray(a, b) {
+    if (a === void 0) {
+      a = [];
+    }
+
+    if (b === void 0) {
+      b = [];
+    }
+
+    return a.length !== b.length || a.some(function (item, index) {
+      return !Object.is(item, b[index]);
+    });
+  };
+
+  var initialState = {
+    error: null
+  };
+
+  var ErrorBoundary = /*#__PURE__*/function (_React$Component) {
+    _inheritsLoose(ErrorBoundary, _React$Component);
+
+    function ErrorBoundary() {
+      var _this;
+
+      for (var _len = arguments.length, _args = new Array(_len), _key = 0; _key < _len; _key++) {
+        _args[_key] = arguments[_key];
+      }
+
+      _this = _React$Component.call.apply(_React$Component, [this].concat(_args)) || this;
+      _this.state = initialState;
+
+      _this.resetErrorBoundary = function () {
+        var _this$props;
+
+        for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+          args[_key2] = arguments[_key2];
+        }
+
+        _this.props.onReset == null ? void 0 : (_this$props = _this.props).onReset.apply(_this$props, args);
+
+        _this.reset();
+      };
+
+      return _this;
+    }
+
+    ErrorBoundary.getDerivedStateFromError = function getDerivedStateFromError(error) {
+      return {
+        error: error
+      };
+    };
+
+    var _proto = ErrorBoundary.prototype;
+
+    _proto.reset = function reset() {
+      this.setState(initialState);
+    };
+
+    _proto.componentDidCatch = function componentDidCatch(error, info) {
+      var _this$props$onError, _this$props2;
+
+      (_this$props$onError = (_this$props2 = this.props).onError) == null ? void 0 : _this$props$onError.call(_this$props2, error, info);
+    };
+
+    _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
+      // the error boundary immediately. This would likely trigger a second
+      // error to be thrown.
+      // 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 && 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);
+        this.reset();
+      }
+    };
+
+    _proto.render = function render() {
+      var error = this.state.error;
+      var _this$props4 = this.props,
+          fallbackRender = _this$props4.fallbackRender,
+          FallbackComponent = _this$props4.FallbackComponent,
+          fallback = _this$props4.fallback;
+
+      if (error !== null) {
+        var _props = {
+          error: error,
+          resetErrorBoundary: this.resetErrorBoundary
+        };
+
+        if ( /*#__PURE__*/React__namespace.isValidElement(fallback)) {
+          return fallback;
+        } else if (typeof fallbackRender === 'function') {
+          return fallbackRender(_props);
+        } else if (FallbackComponent) {
+          return /*#__PURE__*/React__namespace.createElement(FallbackComponent, _props);
+        } else {
+          throw new Error('react-error-boundary requires either a fallback, fallbackRender, or FallbackComponent prop');
+        }
+      }
+
+      return this.props.children;
+    };
+
+    return ErrorBoundary;
+  }(React__namespace.Component);
+
+  function withErrorBoundary(Component, errorBoundaryProps) {
+    var Wrapped = function Wrapped(props) {
+      return /*#__PURE__*/React__namespace.createElement(ErrorBoundary, errorBoundaryProps, /*#__PURE__*/React__namespace.createElement(Component, props));
+    }; // Format for display in DevTools
+
+
+    var name = Component.displayName || Component.name || 'Unknown';
+    Wrapped.displayName = "withErrorBoundary(" + name + ")";
+    return Wrapped;
+  }
+
+  function useErrorHandler(givenError) {
+    var _React$useState = React__namespace.useState(null),
+        error = _React$useState[0],
+        setError = _React$useState[1];
+
+    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"
+  */
+
+  exports.ErrorBoundary = ErrorBoundary;
+  exports.useErrorHandler = useErrorHandler;
+  exports.withErrorBoundary = withErrorBoundary;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=react-error-boundary.umd.js.map

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

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

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

@@ -0,0 +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="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