@prom-ui/core 1.18.0 → 1.19.1

package/ErrorCatch/cjs/index.development.js

@@ -0,0 +1,367 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+var Button = require('@prom-ui/core/Button');
+var useBodyTTag = require('@prom-ui/core/useBodyTTag');
+var Reload = require('@prom-ui/icons/Reload');
+var Close = require('@prom-ui/icons/Close');
+
+function _interopNamespaceCompat(e) {
+    if (e && typeof e === 'object' && 'default' in e) 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__*/_interopNamespaceCompat(React);
+
+var logError = function logError(msg, error, info) {
+  console.error(msg, error, info);
+};
+var setErrorCatchLog = function setErrorCatchLog(fn) {
+  logError = fn;
+};
+
+function _iterableToArrayLimit(arr, i) {
+  var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"];
+  if (null != _i) {
+    var _s,
+      _e,
+      _x,
+      _r,
+      _arr = [],
+      _n = !0,
+      _d = !1;
+    try {
+      if (_x = (_i = _i.call(arr)).next, 0 === i) {
+        if (Object(_i) !== _i) return;
+        _n = !1;
+      } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0);
+    } catch (err) {
+      _d = !0, _e = err;
+    } finally {
+      try {
+        if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return;
+      } finally {
+        if (_d) throw _e;
+      }
+    }
+    return _arr;
+  }
+}
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
+function _defineProperty(obj, key, value) {
+  key = _toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      writable: true,
+      configurable: true
+    }
+  });
+  Object.defineProperty(subClass, "prototype", {
+    writable: false
+  });
+  if (superClass) _setPrototypeOf(subClass, superClass);
+}
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
+  };
+  return _getPrototypeOf(o);
+}
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+  return _setPrototypeOf(o, p);
+}
+function _isNativeReflectConstruct() {
+  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+  if (Reflect.construct.sham) return false;
+  if (typeof Proxy === "function") return true;
+  try {
+    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+  return self;
+}
+function _possibleConstructorReturn(self, call) {
+  if (call && (typeof call === "object" || typeof call === "function")) {
+    return call;
+  } else if (call !== void 0) {
+    throw new TypeError("Derived constructors may only return object or undefined");
+  }
+  return _assertThisInitialized(self);
+}
+function _createSuper(Derived) {
+  var hasNativeReflectConstruct = _isNativeReflectConstruct();
+  return function _createSuperInternal() {
+    var Super = _getPrototypeOf(Derived),
+      result;
+    if (hasNativeReflectConstruct) {
+      var NewTarget = _getPrototypeOf(this).constructor;
+      result = Reflect.construct(Super, arguments, NewTarget);
+    } else {
+      result = Super.apply(this, arguments);
+    }
+    return _possibleConstructorReturn(this, result);
+  };
+}
+function _taggedTemplateLiteral(strings, raw) {
+  if (!raw) {
+    raw = strings.slice(0);
+  }
+  return Object.freeze(Object.defineProperties(strings, {
+    raw: {
+      value: Object.freeze(raw)
+    }
+  }));
+}
+function _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _toPrimitive(input, hint) {
+  if (typeof input !== "object" || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (typeof res !== "object") return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (hint === "string" ? String : Number)(input);
+}
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return typeof key === "symbol" ? key : String(key);
+}
+
+var css = {"root":"ErrorCatch__root___MgWkO","text":"ErrorCatch__text___mFI5O","name":"ErrorCatch__name___-bzUk","button":"ErrorCatch__button___9tlvu"};
+
+var _templateObject, _templateObject2, _templateObject3;
+var ErrorView = function ErrorView(_ref) {
+  var name = _ref.name,
+    onClose = _ref.onClose,
+    onReload = _ref.onReload;
+  var _React$useState = React__namespace.useState(false),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    isLoading = _React$useState2[0],
+    setLoading = _React$useState2[1];
+  var _useBodyTTag = useBodyTTag.useBodyTTag(),
+    t = _useBodyTTag.t;
+  var handleOnReload = function handleOnReload() {
+    setLoading(true);
+    setTimeout(function () {
+      setLoading(false);
+      if (onReload) {
+        onReload();
+      }
+    }, 500);
+  };
+  if (process.env.NODE_ENV !== 'production') {
+    return /*#__PURE__*/React__namespace.createElement("div", {
+      className: css.root,
+      "data-qaid": "error_catch",
+      "data-testid": "error_catch"
+    }, /*#__PURE__*/React__namespace.createElement("div", {
+      className: css.text,
+      "data-qaid": "error_catch_text",
+      "data-testid": "error_catch_text"
+    }, t(_templateObject || (_templateObject = _taggedTemplateLiteral(["\u041E\u0448\u0438\u0431\u043A\u0430:"]))), !!name && /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, ' ', /*#__PURE__*/React__namespace.createElement("span", {
+      className: css.name,
+      "data-qaid": "error_catch_component_name",
+      "data-testid": "error_catch_component_name"
+    }, name))), onReload && /*#__PURE__*/React__namespace.createElement(Button.Button, {
+      "button-theme": "white-inherit",
+      "button-padding": "xxs",
+      type: "button",
+      className: css.button,
+      onClick: handleOnReload,
+      title: t(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\u041E\u0431\u043D\u043E\u0432\u0438\u0442\u044C"]))),
+      loading: isLoading,
+      "data-qaid": "error_catch_button_reload",
+      "data-testid": "error_catch_button_reload"
+    }, /*#__PURE__*/React__namespace.createElement(Reload.SvgReload, {
+      width: 18,
+      height: 18
+    })), onClose && /*#__PURE__*/React__namespace.createElement(Button.Button, {
+      "button-theme": "white-inherit",
+      "button-padding": "xxs",
+      type: "button",
+      disabled: isLoading,
+      className: css.button,
+      onClick: onClose,
+      title: t(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\u0421\u043A\u0440\u044B\u0442\u044C"]))),
+      "data-qaid": "error_catch_button_close",
+      "data-testid": "error_catch_button_close"
+    }, /*#__PURE__*/React__namespace.createElement(Close.SvgClose, {
+      width: 18,
+      height: 18
+    })));
+  }
+  return null;
+};
+ErrorView.displayName = 'ErrorView';
+
+/**
+ * React-компонент, що перехоплює помилки JavaScript у будь-якому місці свого дочірнього дерева компонентів, реєструє ці помилки та відображає резервний користувацький інтерфейс.
+ */
+var ErrorCatch = /*#__PURE__*/function (_React$Component) {
+  _inherits(ErrorCatch, _React$Component);
+  var _super = _createSuper(ErrorCatch);
+  function ErrorCatch(props) {
+    var _this;
+    _classCallCheck(this, ErrorCatch);
+    _this = _super.call(this, props);
+    _defineProperty(_assertThisInitialized(_this), "onClose", function () {
+      _this.setState({
+        isHidden: true
+      });
+    });
+    _defineProperty(_assertThisInitialized(_this), "onReload", function () {
+      _this.setState({
+        isError: false
+      });
+    });
+    _this.state = {
+      isError: false,
+      isHidden: false
+    };
+    return _this;
+  }
+  _createClass(ErrorCatch, [{
+    key: "componentDidCatch",
+    value: function componentDidCatch(error, info) {
+      var name = this.props.name;
+      logError("".concat(name, ": Failed to render component"), error, info);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+        name = _this$props.name,
+        errorView = _this$props.errorView,
+        children = _this$props.children;
+      var _this$state = this.state,
+        isError = _this$state.isError,
+        isHidden = _this$state.isHidden;
+      if (isHidden) {
+        return null;
+      }
+      if (isError) {
+        if (typeof window === 'undefined') return null;
+        if (errorView && /*#__PURE__*/React__namespace.isValidElement(errorView)) {
+          return /*#__PURE__*/React__namespace.cloneElement(errorView, {
+            name: name,
+            onReload: this.onReload,
+            onClose: this.onClose
+          });
+        }
+        return null;
+      }
+      return children;
+    }
+  }], [{
+    key: "getDerivedStateFromError",
+    value: function getDerivedStateFromError() {
+      return {
+        isError: true
+      };
+    }
+  }]);
+  return ErrorCatch;
+}(React__namespace.Component);
+_defineProperty(ErrorCatch, "defaultProps", {
+  errorView: /*#__PURE__*/React__namespace.createElement(ErrorView, null)
+});
+
+var withErrorCatch = function withErrorCatch(Component, errorCatchProps) {
+  var WithErrorCatch = function WithErrorCatch(props) {
+    return /*#__PURE__*/React__namespace.createElement(ErrorCatch, errorCatchProps, /*#__PURE__*/React__namespace.createElement(Component, props));
+  };
+  WithErrorCatch.displayName = 'WithErrorCatch';
+  return WithErrorCatch;
+};
+
+exports.ErrorCatch = ErrorCatch;
+exports.setErrorCatchLog = setErrorCatchLog;
+exports.withErrorCatch = withErrorCatch;
+
+require('./style.development.css');