@stokr/components-library 3.0.65 → 3.0.67

package/dist/node_modules/raf/index.js

@@ -0,0 +1,67 @@
+import { commonjsGlobal } from "../../_virtual/_commonjsHelpers.js";
+import { __module as raf } from "../../_virtual/index25.js";
+import { __require as requirePerformanceNow } from "../performance-now/lib/performance-now.js";
+var hasRequiredRaf;
+function requireRaf() {
+  if (hasRequiredRaf) return raf.exports;
+  hasRequiredRaf = 1;
+  var now = requirePerformanceNow(), root = typeof window === "undefined" ? commonjsGlobal : window, vendors = ["moz", "webkit"], suffix = "AnimationFrame", raf$1 = root["request" + suffix], caf = root["cancel" + suffix] || root["cancelRequest" + suffix];
+  for (var i = 0; !raf$1 && i < vendors.length; i++) {
+    raf$1 = root[vendors[i] + "Request" + suffix];
+    caf = root[vendors[i] + "Cancel" + suffix] || root[vendors[i] + "CancelRequest" + suffix];
+  }
+  if (!raf$1 || !caf) {
+    var last = 0, id = 0, queue = [], frameDuration = 1e3 / 60;
+    raf$1 = function(callback) {
+      if (queue.length === 0) {
+        var _now = now(), next = Math.max(0, frameDuration - (_now - last));
+        last = next + _now;
+        setTimeout(function() {
+          var cp = queue.slice(0);
+          queue.length = 0;
+          for (var i2 = 0; i2 < cp.length; i2++) {
+            if (!cp[i2].cancelled) {
+              try {
+                cp[i2].callback(last);
+              } catch (e) {
+                setTimeout(function() {
+                  throw e;
+                }, 0);
+              }
+            }
+          }
+        }, Math.round(next));
+      }
+      queue.push({
+        handle: ++id,
+        callback,
+        cancelled: false
+      });
+      return id;
+    };
+    caf = function(handle) {
+      for (var i2 = 0; i2 < queue.length; i2++) {
+        if (queue[i2].handle === handle) {
+          queue[i2].cancelled = true;
+        }
+      }
+    };
+  }
+  raf.exports = function(fn) {
+    return raf$1.call(root, fn);
+  };
+  raf.exports.cancel = function() {
+    caf.apply(root, arguments);
+  };
+  raf.exports.polyfill = function(object) {
+    if (!object) {
+      object = root;
+    }
+    object.requestAnimationFrame = raf$1;
+    object.cancelAnimationFrame = caf;
+  };
+  return raf.exports;
+}
+export {
+  requireRaf as __require
+};

package/dist/node_modules/react-collapse/lib/Collapse.js

@@ -0,0 +1,285 @@
+import { __exports as Collapse } from "../../../_virtual/Collapse.js";
+import React__default from "react";
+var hasRequiredCollapse;
+function requireCollapse() {
+  if (hasRequiredCollapse) return Collapse;
+  hasRequiredCollapse = 1;
+  function _typeof(obj) {
+    "@babel/helpers - typeof";
+    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+      _typeof = function _typeof2(obj2) {
+        return typeof obj2;
+      };
+    } else {
+      _typeof = function _typeof2(obj2) {
+        return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+      };
+    }
+    return _typeof(obj);
+  }
+  Object.defineProperty(Collapse, "__esModule", {
+    value: true
+  });
+  Collapse.Collapse = void 0;
+  var _react = _interopRequireDefault(React__default);
+  function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : { "default": obj };
+  }
+  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, descriptor.key, descriptor);
+    }
+  }
+  function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    return Constructor;
+  }
+  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 } });
+    if (superClass) _setPrototypeOf(subClass, superClass);
+  }
+  function _setPrototypeOf(o, p) {
+    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf2(o2, p2) {
+      o2.__proto__ = p2;
+      return o2;
+    };
+    return _setPrototypeOf(o, p);
+  }
+  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 _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 _assertThisInitialized(self) {
+    if (self === void 0) {
+      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+  }
+  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 _getPrototypeOf(o) {
+    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf2(o2) {
+      return o2.__proto__ || Object.getPrototypeOf(o2);
+    };
+    return _getPrototypeOf(o);
+  }
+  function _defineProperty(obj, key, value) {
+    if (key in obj) {
+      Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+    } else {
+      obj[key] = value;
+    }
+    return obj;
+  }
+  var Collapse$1 = /* @__PURE__ */ (function(_React$Component) {
+    _inherits(Collapse2, _React$Component);
+    var _super = _createSuper(Collapse2);
+    function Collapse2(props) {
+      var _this;
+      _classCallCheck(this, Collapse2);
+      _this = _super.call(this, props);
+      _defineProperty(_assertThisInitialized(_this), "timeout", void 0);
+      _defineProperty(_assertThisInitialized(_this), "container", void 0);
+      _defineProperty(_assertThisInitialized(_this), "content", void 0);
+      _defineProperty(_assertThisInitialized(_this), "onResize", function() {
+        clearTimeout(_this.timeout);
+        if (!_this.container || !_this.content) {
+          return;
+        }
+        var _this$props = _this.props, isOpened = _this$props.isOpened, checkTimeout = _this$props.checkTimeout;
+        var containerHeight = Math.floor(_this.container.clientHeight);
+        var contentHeight = Math.floor(_this.content.clientHeight);
+        var isFullyOpened = isOpened && Math.abs(contentHeight - containerHeight) <= 1;
+        var isFullyClosed = !isOpened && Math.abs(containerHeight) <= 1;
+        if (isFullyOpened || isFullyClosed) {
+          _this.onRest({
+            isFullyOpened,
+            isFullyClosed,
+            isOpened,
+            containerHeight,
+            contentHeight
+          });
+        } else {
+          _this.onWork({
+            isFullyOpened,
+            isFullyClosed,
+            isOpened,
+            containerHeight,
+            contentHeight
+          });
+          _this.timeout = setTimeout(function() {
+            return _this.onResize();
+          }, checkTimeout);
+        }
+      });
+      _defineProperty(_assertThisInitialized(_this), "onRest", function(_ref) {
+        var isFullyOpened = _ref.isFullyOpened, isFullyClosed = _ref.isFullyClosed, isOpened = _ref.isOpened, containerHeight = _ref.containerHeight, contentHeight = _ref.contentHeight;
+        if (!_this.container || !_this.content) {
+          return;
+        }
+        var hasOpened = isOpened && _this.container.style.height === "".concat(contentHeight, "px");
+        var hasClosed = !isOpened && _this.container.style.height === "0px";
+        if (hasOpened || hasClosed) {
+          _this.container.style.overflow = isOpened ? "initial" : "hidden";
+          _this.container.style.height = isOpened ? "auto" : "0px";
+          var onRest = _this.props.onRest;
+          if (onRest) {
+            onRest({
+              isFullyOpened,
+              isFullyClosed,
+              isOpened,
+              containerHeight,
+              contentHeight
+            });
+          }
+        }
+      });
+      _defineProperty(_assertThisInitialized(_this), "onWork", function(_ref2) {
+        var isFullyOpened = _ref2.isFullyOpened, isFullyClosed = _ref2.isFullyClosed, isOpened = _ref2.isOpened, containerHeight = _ref2.containerHeight, contentHeight = _ref2.contentHeight;
+        if (!_this.container || !_this.content) {
+          return;
+        }
+        var isOpenining = isOpened && _this.container.style.height === "".concat(contentHeight, "px");
+        var isClosing = !isOpened && _this.container.style.height === "0px";
+        if (isOpenining || isClosing) {
+          return;
+        }
+        _this.container.style.overflow = "hidden";
+        _this.container.style.height = isOpened ? "".concat(contentHeight, "px") : "0px";
+        var onWork = _this.props.onWork;
+        if (onWork) {
+          onWork({
+            isFullyOpened,
+            isFullyClosed,
+            isOpened,
+            containerHeight,
+            contentHeight
+          });
+        }
+      });
+      _defineProperty(_assertThisInitialized(_this), "onRefContainer", function(container) {
+        _this.container = container;
+      });
+      _defineProperty(_assertThisInitialized(_this), "onRefContent", function(content) {
+        _this.content = content;
+      });
+      if (props.initialStyle) {
+        _this.initialStyle = props.initialStyle;
+      } else {
+        _this.initialStyle = props.isOpened ? {
+          height: "auto",
+          overflow: "initial"
+        } : {
+          height: "0px",
+          overflow: "hidden"
+        };
+      }
+      return _this;
+    }
+    _createClass(Collapse2, [{
+      key: "componentDidMount",
+      value: function componentDidMount() {
+        this.onResize();
+      }
+    }, {
+      key: "shouldComponentUpdate",
+      value: function shouldComponentUpdate(nextProps) {
+        var _this$props2 = this.props, theme = _this$props2.theme, isOpened = _this$props2.isOpened, children = _this$props2.children;
+        return children !== nextProps.children || isOpened !== nextProps.isOpened || Object.keys(theme).some(function(c) {
+          return theme[c] !== nextProps.theme[c];
+        });
+      }
+    }, {
+      key: "getSnapshotBeforeUpdate",
+      value: function getSnapshotBeforeUpdate() {
+        if (!this.container || !this.content) {
+          return null;
+        }
+        if (this.container.style.height === "auto") {
+          var contentHeight = this.content.clientHeight;
+          this.container.style.height = "".concat(contentHeight, "px");
+        }
+        return null;
+      }
+    }, {
+      key: "componentDidUpdate",
+      value: function componentDidUpdate() {
+        this.onResize();
+      }
+    }, {
+      key: "componentWillUnmount",
+      value: function componentWillUnmount() {
+        clearTimeout(this.timeout);
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var _this$props3 = this.props, theme = _this$props3.theme, children = _this$props3.children, isOpened = _this$props3.isOpened;
+        return /* @__PURE__ */ _react["default"].createElement("div", {
+          ref: this.onRefContainer,
+          className: theme.collapse,
+          style: this.initialStyle,
+          "aria-hidden": !isOpened
+        }, /* @__PURE__ */ _react["default"].createElement("div", {
+          ref: this.onRefContent,
+          className: theme.content
+        }, children));
+      }
+    }]);
+    return Collapse2;
+  })(_react["default"].Component);
+  Collapse.Collapse = Collapse$1;
+  _defineProperty(Collapse$1, "defaultProps", {
+    theme: {
+      collapse: "ReactCollapse--collapse",
+      content: "ReactCollapse--content"
+    },
+    initialStyle: void 0,
+    onRest: void 0,
+    onWork: void 0,
+    checkTimeout: 50
+  });
+  return Collapse;
+}
+export {
+  requireCollapse as __require
+};

package/dist/node_modules/react-collapse/lib/UnmountClosed.js

@@ -0,0 +1,278 @@
+import { __exports as UnmountClosed } from "../../../_virtual/UnmountClosed.js";
+import React__default from "react";
+import { __require as requireCollapse } from "./Collapse.js";
+var hasRequiredUnmountClosed;
+function requireUnmountClosed() {
+  if (hasRequiredUnmountClosed) return UnmountClosed;
+  hasRequiredUnmountClosed = 1;
+  function _typeof(obj) {
+    "@babel/helpers - typeof";
+    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+      _typeof = function _typeof2(obj2) {
+        return typeof obj2;
+      };
+    } else {
+      _typeof = function _typeof2(obj2) {
+        return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+      };
+    }
+    return _typeof(obj);
+  }
+  Object.defineProperty(UnmountClosed, "__esModule", {
+    value: true
+  });
+  UnmountClosed.UnmountClosed = void 0;
+  var _react = _interopRequireDefault(React__default);
+  var _Collapse = requireCollapse();
+  var _excluded = ["isOpened"], _excluded2 = ["isOpened"];
+  function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : { "default": obj };
+  }
+  function _extends() {
+    _extends = Object.assign || function(target) {
+      for (var i = 1; i < arguments.length; i++) {
+        var source = arguments[i];
+        for (var key in source) {
+          if (Object.prototype.hasOwnProperty.call(source, key)) {
+            target[key] = source[key];
+          }
+        }
+      }
+      return target;
+    };
+    return _extends.apply(this, arguments);
+  }
+  function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+      var symbols = Object.getOwnPropertySymbols(object);
+      if (enumerableOnly) {
+        symbols = symbols.filter(function(sym) {
+          return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+        });
+      }
+      keys.push.apply(keys, symbols);
+    }
+    return keys;
+  }
+  function _objectSpread(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i] != null ? arguments[i] : {};
+      if (i % 2) {
+        ownKeys(Object(source), true).forEach(function(key) {
+          _defineProperty(target, key, source[key]);
+        });
+      } else if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+      } else {
+        ownKeys(Object(source)).forEach(function(key) {
+          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+      }
+    }
+    return target;
+  }
+  function _objectWithoutProperties(source, excluded) {
+    if (source == null) return {};
+    var target = _objectWithoutPropertiesLoose(source, excluded);
+    var key, i;
+    if (Object.getOwnPropertySymbols) {
+      var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+      for (i = 0; i < sourceSymbolKeys.length; i++) {
+        key = sourceSymbolKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+        target[key] = source[key];
+      }
+    }
+    return target;
+  }
+  function _objectWithoutPropertiesLoose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for (i = 0; i < sourceKeys.length; i++) {
+      key = sourceKeys[i];
+      if (excluded.indexOf(key) >= 0) continue;
+      target[key] = source[key];
+    }
+    return target;
+  }
+  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, descriptor.key, descriptor);
+    }
+  }
+  function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    return Constructor;
+  }
+  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 } });
+    if (superClass) _setPrototypeOf(subClass, superClass);
+  }
+  function _setPrototypeOf(o, p) {
+    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf2(o2, p2) {
+      o2.__proto__ = p2;
+      return o2;
+    };
+    return _setPrototypeOf(o, p);
+  }
+  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 _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 _assertThisInitialized(self) {
+    if (self === void 0) {
+      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+  }
+  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 _getPrototypeOf(o) {
+    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf2(o2) {
+      return o2.__proto__ || Object.getPrototypeOf(o2);
+    };
+    return _getPrototypeOf(o);
+  }
+  function _defineProperty(obj, key, value) {
+    if (key in obj) {
+      Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+    } else {
+      obj[key] = value;
+    }
+    return obj;
+  }
+  var UnmountClosed$1 = /* @__PURE__ */ (function(_React$PureComponent) {
+    _inherits(UnmountClosed2, _React$PureComponent);
+    var _super = _createSuper(UnmountClosed2);
+    function UnmountClosed2(props) {
+      var _this;
+      _classCallCheck(this, UnmountClosed2);
+      _this = _super.call(this, props);
+      _defineProperty(_assertThisInitialized(_this), "onWork", function(_ref) {
+        var isOpened = _ref.isOpened, rest = _objectWithoutProperties(_ref, _excluded);
+        _this.setState({
+          isResting: false,
+          isOpened
+        });
+        var onWork = _this.props.onWork;
+        if (onWork) {
+          onWork(_objectSpread({
+            isOpened
+          }, rest));
+        }
+      });
+      _defineProperty(_assertThisInitialized(_this), "onRest", function(_ref2) {
+        var isOpened = _ref2.isOpened, rest = _objectWithoutProperties(_ref2, _excluded2);
+        _this.setState({
+          isResting: true,
+          isOpened,
+          isInitialRender: false
+        });
+        var onRest = _this.props.onRest;
+        if (onRest) {
+          onRest(_objectSpread({
+            isOpened
+          }, rest));
+        }
+      });
+      _defineProperty(_assertThisInitialized(_this), "getInitialStyle", function() {
+        var _this$state = _this.state, isOpened = _this$state.isOpened, isInitialRender = _this$state.isInitialRender;
+        if (isInitialRender) {
+          return isOpened ? {
+            height: "auto",
+            overflow: "initial"
+          } : {
+            height: "0px",
+            overflow: "hidden"
+          };
+        }
+        return {
+          height: "0px",
+          overflow: "hidden"
+        };
+      });
+      _this.state = {
+        isResting: true,
+        isOpened: props.isOpened,
+        isInitialRender: true
+      };
+      return _this;
+    }
+    _createClass(UnmountClosed2, [{
+      key: "componentDidUpdate",
+      value: function componentDidUpdate(prevProps) {
+        var isOpened = this.props.isOpened;
+        if (prevProps.isOpened !== isOpened) {
+          this.setState({
+            isResting: false,
+            isOpened,
+            isInitialRender: false
+          });
+        }
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var _this$state2 = this.state, isResting = _this$state2.isResting, isOpened = _this$state2.isOpened;
+        return isResting && !isOpened ? null : /* @__PURE__ */ _react["default"].createElement(_Collapse.Collapse, _extends({}, this.props, {
+          initialStyle: this.getInitialStyle(),
+          onWork: this.onWork,
+          onRest: this.onRest
+        }));
+      }
+    }]);
+    return UnmountClosed2;
+  })(_react["default"].PureComponent);
+  UnmountClosed.UnmountClosed = UnmountClosed$1;
+  _defineProperty(UnmountClosed$1, "defaultProps", {
+    onWork: void 0,
+    onRest: void 0
+  });
+  return UnmountClosed;
+}
+export {
+  requireUnmountClosed as __require
+};

package/dist/node_modules/react-collapse/lib/index.js

@@ -0,0 +1,17 @@
+import { __require as requireCollapse } from "./Collapse.js";
+import { __require as requireUnmountClosed } from "./UnmountClosed.js";
+var lib;
+var hasRequiredLib;
+function requireLib() {
+  if (hasRequiredLib) return lib;
+  hasRequiredLib = 1;
+  var _require = requireCollapse(), Collapse = _require.Collapse;
+  var _require2 = requireUnmountClosed(), UnmountClosed = _require2.UnmountClosed;
+  lib = UnmountClosed;
+  UnmountClosed.Collapse = Collapse;
+  UnmountClosed.UnmountClosed = UnmountClosed;
+  return lib;
+}
+export {
+  requireLib as __require
+};