@stokr/components-library 3.0.65 → 3.0.67

package/dist/node_modules/react-range/lib/utils.js

@@ -0,0 +1,318 @@
+import { __exports as utils } from "../../../_virtual/utils.js";
+import React__default from "react";
+import { __require as requireTypes } from "./types.js";
+var hasRequiredUtils;
+function requireUtils() {
+  if (hasRequiredUtils) return utils;
+  hasRequiredUtils = 1;
+  (function(exports$1) {
+    var __spreadArray = utils && utils.__spreadArray || function(to, from, pack) {
+      if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+          ar[i] = from[i];
+        }
+      }
+      return to.concat(ar || Array.prototype.slice.call(from));
+    };
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.isIOS = exports$1.useThumbOverlap = exports$1.assertUnreachable = exports$1.voidFn = exports$1.getTrackBackground = exports$1.replaceAt = exports$1.schd = exports$1.translate = exports$1.getClosestThumbIndex = exports$1.translateThumbs = exports$1.getPaddingAndBorder = exports$1.getMargin = exports$1.checkInitialOverlap = exports$1.checkValuesAgainstBoundaries = exports$1.checkBoundaries = exports$1.isVertical = exports$1.relativeValue = exports$1.normalizeValue = exports$1.isStepDivisible = exports$1.isTouchEvent = exports$1.getStepDecimals = void 0;
+    var react_1 = React__default;
+    var types_1 = /* @__PURE__ */ requireTypes();
+    var getStepDecimals = function(step) {
+      var decimals = step.toString().split(".")[1];
+      return decimals ? decimals.length : 0;
+    };
+    exports$1.getStepDecimals = getStepDecimals;
+    function isTouchEvent(event) {
+      return event.touches && event.touches.length || event.changedTouches && event.changedTouches.length;
+    }
+    exports$1.isTouchEvent = isTouchEvent;
+    function isStepDivisible(min, max, step) {
+      var res = (max - min) / step;
+      var precision = 8;
+      var roundedRes = Number(res.toFixed(precision));
+      return parseInt(roundedRes.toString(), 10) === roundedRes;
+    }
+    exports$1.isStepDivisible = isStepDivisible;
+    function normalizeValue(value, index, min, max, step, allowOverlap, values) {
+      var BIG_NUM = 1e11;
+      value = Math.round(value * BIG_NUM) / BIG_NUM;
+      if (!allowOverlap) {
+        var prev = values[index - 1];
+        var next = values[index + 1];
+        if (prev && prev > value)
+          return prev;
+        if (next && next < value)
+          return next;
+      }
+      if (value > max)
+        return max;
+      if (value < min)
+        return min;
+      var remainder = Math.floor(value * BIG_NUM - min * BIG_NUM) % Math.floor(step * BIG_NUM);
+      var closestLowerNum = Math.floor(value * BIG_NUM - Math.abs(remainder));
+      var rounded = remainder === 0 ? value : closestLowerNum / BIG_NUM;
+      var res = Math.abs(remainder / BIG_NUM) < step / 2 ? rounded : rounded + step;
+      var decimalPlaces = (0, exports$1.getStepDecimals)(step);
+      return parseFloat(res.toFixed(decimalPlaces));
+    }
+    exports$1.normalizeValue = normalizeValue;
+    function relativeValue(value, min, max) {
+      return (value - min) / (max - min);
+    }
+    exports$1.relativeValue = relativeValue;
+    function isVertical(direction) {
+      return direction === types_1.Direction.Up || direction === types_1.Direction.Down;
+    }
+    exports$1.isVertical = isVertical;
+    function checkBoundaries(value, min, max) {
+      if (min >= max) {
+        throw new RangeError("min (".concat(min, ") is equal/bigger than max (").concat(max, ")"));
+      }
+      if (value < min) {
+        throw new RangeError("value (".concat(value, ") is smaller than min (").concat(min, ")"));
+      }
+      if (value > max) {
+        throw new RangeError("value (".concat(value, ") is bigger than max (").concat(max, ")"));
+      }
+    }
+    exports$1.checkBoundaries = checkBoundaries;
+    function checkValuesAgainstBoundaries(value, min, max) {
+      if (value < min) {
+        return min;
+      }
+      if (value > max) {
+        return max;
+      } else {
+        return value;
+      }
+    }
+    exports$1.checkValuesAgainstBoundaries = checkValuesAgainstBoundaries;
+    function checkInitialOverlap(values) {
+      if (values.length < 2)
+        return;
+      if (!values.slice(1).every(function(item, i) {
+        return values[i] <= item;
+      })) {
+        throw new RangeError("values={[".concat(values, "]} needs to be sorted when allowOverlap={false}"));
+      }
+    }
+    exports$1.checkInitialOverlap = checkInitialOverlap;
+    function getMargin(element) {
+      var style = window.getComputedStyle(element);
+      return {
+        top: parseInt(style["margin-top"], 10),
+        bottom: parseInt(style["margin-bottom"], 10),
+        left: parseInt(style["margin-left"], 10),
+        right: parseInt(style["margin-right"], 10)
+      };
+    }
+    exports$1.getMargin = getMargin;
+    function getPaddingAndBorder(element) {
+      var style = window.getComputedStyle(element);
+      return {
+        top: parseInt(style["padding-top"], 10) + parseInt(style["border-top-width"], 10),
+        bottom: parseInt(style["padding-bottom"], 10) + parseInt(style["border-bottom-width"], 10),
+        left: parseInt(style["padding-left"], 10) + parseInt(style["border-left-width"], 10),
+        right: parseInt(style["padding-right"], 10) + parseInt(style["border-right-width"], 10)
+      };
+    }
+    exports$1.getPaddingAndBorder = getPaddingAndBorder;
+    function translateThumbs(elements, offsets, rtl) {
+      var inverter = rtl ? -1 : 1;
+      elements.forEach(function(element, index) {
+        return translate(element, inverter * offsets[index].x, offsets[index].y);
+      });
+    }
+    exports$1.translateThumbs = translateThumbs;
+    function getClosestThumbIndex(thumbs, clientX, clientY, direction) {
+      var thumbIndex = 0;
+      var minThumbDistance = getThumbDistance(thumbs[0], clientX, clientY, direction);
+      for (var i = 1; i < thumbs.length; i++) {
+        var thumbDistance = getThumbDistance(thumbs[i], clientX, clientY, direction);
+        if (thumbDistance < minThumbDistance) {
+          minThumbDistance = thumbDistance;
+          thumbIndex = i;
+        }
+      }
+      return thumbIndex;
+    }
+    exports$1.getClosestThumbIndex = getClosestThumbIndex;
+    function translate(element, x, y) {
+      element.style.transform = "translate(".concat(x, "px, ").concat(y, "px)");
+    }
+    exports$1.translate = translate;
+    var schd = function(fn) {
+      var lastArgs = [];
+      var frameId = null;
+      var wrapperFn = function() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        lastArgs = args;
+        if (frameId) {
+          return;
+        }
+        frameId = requestAnimationFrame(function() {
+          frameId = null;
+          fn.apply(void 0, lastArgs);
+        });
+      };
+      return wrapperFn;
+    };
+    exports$1.schd = schd;
+    function replaceAt(values, index, value) {
+      var ret = values.slice(0);
+      ret[index] = value;
+      return ret;
+    }
+    exports$1.replaceAt = replaceAt;
+    function getTrackBackground(_a) {
+      var values = _a.values, colors = _a.colors, min = _a.min, max = _a.max, _b = _a.direction, direction = _b === void 0 ? types_1.Direction.Right : _b, _c = _a.rtl, rtl = _c === void 0 ? false : _c;
+      if (rtl && direction === types_1.Direction.Right) {
+        direction = types_1.Direction.Left;
+      } else if (rtl && types_1.Direction.Left) {
+        direction = types_1.Direction.Right;
+      }
+      var progress = values.slice(0).sort(function(a, b) {
+        return a - b;
+      }).map(function(value) {
+        return (value - min) / (max - min) * 100;
+      });
+      var middle = progress.reduce(function(acc, point, index) {
+        return "".concat(acc, ", ").concat(colors[index], " ").concat(point, "%, ").concat(colors[index + 1], " ").concat(point, "%");
+      }, "");
+      return "linear-gradient(".concat(direction, ", ").concat(colors[0], " 0%").concat(middle, ", ").concat(colors[colors.length - 1], " 100%)");
+    }
+    exports$1.getTrackBackground = getTrackBackground;
+    function voidFn() {
+    }
+    exports$1.voidFn = voidFn;
+    function assertUnreachable(x) {
+      throw new Error("Didn't expect to get here");
+    }
+    exports$1.assertUnreachable = assertUnreachable;
+    var getThumbWidth = function(thumbEl, value, separator, decimalPlaces, valueToLabel) {
+      if (valueToLabel === void 0) {
+        valueToLabel = function(value2) {
+          return value2;
+        };
+      }
+      var width = Math.ceil(__spreadArray([thumbEl], Array.from(thumbEl.children), true).reduce(function(width2, el) {
+        var elWidth = Math.ceil(el.getBoundingClientRect().width);
+        if (el.innerText && el.innerText.includes(separator) && el.childElementCount === 0) {
+          var elClone = el.cloneNode(true);
+          elClone.innerHTML = valueToLabel(value.toFixed(decimalPlaces));
+          elClone.style.visibility = "hidden";
+          document.body.appendChild(elClone);
+          elWidth = Math.ceil(elClone.getBoundingClientRect().width);
+          document.body.removeChild(elClone);
+        }
+        return elWidth > width2 ? elWidth : width2;
+      }, thumbEl.getBoundingClientRect().width));
+      return width;
+    };
+    var getOverlaps = function(index, offsets, thumbs, values, separator, decimalPlaces, valueToLabel) {
+      if (valueToLabel === void 0) {
+        valueToLabel = function(value) {
+          return value;
+        };
+      }
+      var overlaps = [];
+      var buildOverlaps = function(thumbIndex) {
+        var thumbXWidth = getThumbWidth(thumbs[thumbIndex], values[thumbIndex], separator, decimalPlaces, valueToLabel);
+        var thumbX = offsets[thumbIndex].x;
+        offsets.forEach(function(_a, siblingIndex) {
+          var siblingX = _a.x;
+          var siblingWidth = getThumbWidth(thumbs[siblingIndex], values[siblingIndex], separator, decimalPlaces, valueToLabel);
+          if (thumbIndex !== siblingIndex && (thumbX >= siblingX && thumbX <= siblingX + siblingWidth || thumbX + thumbXWidth >= siblingX && thumbX + thumbXWidth <= siblingX + siblingWidth)) {
+            if (!overlaps.includes(siblingIndex)) {
+              overlaps.push(thumbIndex);
+              overlaps.push(siblingIndex);
+              overlaps = __spreadArray(__spreadArray([], overlaps, true), [thumbIndex, siblingIndex], false);
+              buildOverlaps(siblingIndex);
+            }
+          }
+        });
+      };
+      buildOverlaps(index);
+      return Array.from(new Set(overlaps.sort()));
+    };
+    var useThumbOverlap = function(rangeRef, values, index, step, separator, valueToLabel) {
+      if (step === void 0) {
+        step = 0.1;
+      }
+      if (separator === void 0) {
+        separator = " - ";
+      }
+      if (valueToLabel === void 0) {
+        valueToLabel = function(value) {
+          return value;
+        };
+      }
+      var decimalPlaces = (0, exports$1.getStepDecimals)(step);
+      var _a = (0, react_1.useState)({}), labelStyle = _a[0], setLabelStyle = _a[1];
+      var _b = (0, react_1.useState)(valueToLabel(values[index].toFixed(decimalPlaces))), labelValue = _b[0], setLabelValue = _b[1];
+      (0, react_1.useEffect)(function() {
+        if (rangeRef) {
+          var thumbs = rangeRef.getThumbs();
+          if (thumbs.length < 1)
+            return;
+          var newStyle = {};
+          var offsets_1 = rangeRef.getOffsets();
+          var overlaps = getOverlaps(index, offsets_1, thumbs, values, separator, decimalPlaces, valueToLabel);
+          var labelValue_1 = valueToLabel(values[index].toFixed(decimalPlaces));
+          if (overlaps.length) {
+            var offsetsX = overlaps.reduce(function(a, c, i, s) {
+              return a.length ? __spreadArray(__spreadArray([], a, true), [offsets_1[s[i]].x], false) : [offsets_1[s[i]].x];
+            }, []);
+            if (Math.min.apply(Math, offsetsX) === offsets_1[index].x) {
+              var labelValues_1 = [];
+              overlaps.forEach(function(thumb) {
+                labelValues_1.push(values[thumb].toFixed(decimalPlaces));
+              });
+              labelValue_1 = Array.from(new Set(labelValues_1.sort(function(a, b) {
+                return parseFloat(a) - parseFloat(b);
+              }))).map(valueToLabel).join(separator);
+              var first = Math.min.apply(Math, offsetsX);
+              var last = Math.max.apply(Math, offsetsX);
+              var lastWidth = thumbs[overlaps[offsetsX.indexOf(last)]].getBoundingClientRect().width;
+              newStyle.left = "".concat(Math.abs(first - (last + lastWidth)) / 2, "px");
+              newStyle.transform = "translate(-50%, 0)";
+            } else {
+              newStyle.visibility = "hidden";
+            }
+          }
+          setLabelValue(labelValue_1);
+          setLabelStyle(newStyle);
+        }
+      }, [rangeRef, values]);
+      return [labelValue, labelStyle];
+    };
+    exports$1.useThumbOverlap = useThumbOverlap;
+    function getThumbDistance(thumbEl, clientX, clientY, direction) {
+      var _a = thumbEl.getBoundingClientRect(), left = _a.left, top = _a.top, width = _a.width, height = _a.height;
+      return isVertical(direction) ? Math.abs(clientY - (top + height / 2)) : Math.abs(clientX - (left + width / 2));
+    }
+    var isIOS = function() {
+      var _a;
+      var platform = ((_a = navigator.userAgentData) === null || _a === void 0 ? void 0 : _a.platform) || navigator.platform;
+      return [
+        "iPad Simulator",
+        "iPhone Simulator",
+        "iPod Simulator",
+        "iPad",
+        "iPhone",
+        "iPod"
+      ].includes(platform) || // iPad on iOS 13 detection
+      navigator.userAgent.includes("Mac") && "ontouchend" in document;
+    };
+    exports$1.isIOS = isIOS;
+  })(utils);
+  return utils;
+}
+export {
+  requireUtils as __require
+};

package/dist/node_modules/react-select/creatable/dist/react-select-creatable.esm.js

@@ -0,0 +1,19 @@
+import _extends from "../../../@babel/runtime/helpers/esm/extends.js";
+import * as React from "react";
+import { forwardRef } from "react";
+import { S as Select } from "../../dist/Select-ef7c0426.esm.js";
+import { u as useStateManager } from "../../dist/useStateManager-7e1e8489.esm.js";
+import { u as useCreatable } from "../../dist/useCreatable-09aaeb9a.esm.js";
+import "react-dom";
+var CreatableSelect = /* @__PURE__ */ forwardRef(function(props, ref) {
+  var creatableProps = useStateManager(props);
+  var selectProps = useCreatable(creatableProps);
+  return /* @__PURE__ */ React.createElement(Select, _extends({
+    ref
+  }, selectProps));
+});
+var CreatableSelect$1 = CreatableSelect;
+export {
+  CreatableSelect$1 as default,
+  useCreatable
+};