@salutejs/plasma-new-hope 0.326.0-canary.2016.15556762192.0 → 0.326.0-dev.0

package/emotion/es/components/Carousel/CarouselNew/hooks/useCarousel.js

@@ -0,0 +1,366 @@
+import { useEffect, useCallback, useRef, useMemo } from 'react';
+import throttle from 'lodash.throttle';
+/**
+ * Подсчет смещения из-за паддингов.
+ */
+export var getCalculatedOffset = function getCalculatedOffset(scrollEl, trackEl) {
+  var paddingProp = 'paddingLeft';
+  return parseInt(getComputedStyle(scrollEl)[paddingProp], 10) + parseInt(getComputedStyle(trackEl)[paddingProp], 10);
+};
+var positionModByScrollAlign = function positionModByScrollAlign(_ref) {
+  var scrollAlign = _ref.scrollAlign,
+    position = _ref.position,
+    carouselSize = _ref.carouselSize,
+    itemSize = _ref.itemSize,
+    offset = _ref.offset,
+    scrollStart = _ref.scrollStart;
+  if (scrollAlign === 'start') {
+    var paddingOffset = 0;
+    return position + paddingOffset;
+  }
+  if (scrollAlign === 'center') {
+    return position - carouselSize / 2 + itemSize / 2;
+  }
+  if (scrollAlign === 'end') {
+    return position - carouselSize + itemSize + offset;
+  }
+  if (scrollAlign === 'activeDirection') {
+    if (position >= scrollStart + carouselSize - itemSize) {
+      return position - carouselSize + itemSize + offset;
+    }
+    if (position > scrollStart) {
+      return scrollStart;
+    }
+  }
+  return position;
+};
+
+/**
+ * Подсчет скролла до переданного индекса.
+ */
+export var getCalculatedPos = function getCalculatedPos(_ref2) {
+  var _items$item$offsetWid2, _items$item2;
+  var scrollEl = _ref2.scrollEl,
+    items = _ref2.items,
+    index = _ref2.index,
+    offset = _ref2.offset,
+    scrollAlign = _ref2.scrollAlign;
+  var position = scrollAlign === 'center' ? offset : 0;
+  if (items.item(index) === null) {
+    return position;
+  }
+  for (var i = 0; i < index; i++) {
+    var _items$item$offsetWid, _items$item;
+    position += (_items$item$offsetWid = (_items$item = items.item(i)) === null || _items$item === void 0 ? void 0 : _items$item.offsetWidth) !== null && _items$item$offsetWid !== void 0 ? _items$item$offsetWid : 0;
+  }
+  var carouselSize = scrollEl.offsetWidth;
+  var itemSize = (_items$item$offsetWid2 = (_items$item2 = items.item(index)) === null || _items$item2 === void 0 ? void 0 : _items$item2.offsetWidth) !== null && _items$item$offsetWid2 !== void 0 ? _items$item$offsetWid2 : 0;
+  var scrollStart = scrollEl.scrollLeft;
+  return positionModByScrollAlign({
+    scrollAlign: scrollAlign,
+    position: position,
+    carouselSize: carouselSize,
+    itemSize: itemSize,
+    offset: offset,
+    scrollStart: scrollStart
+  });
+};
+var DEFAULT_DURATION = 300;
+
+// https://css-tricks.com/emulating-css-timing-functions-javascript/
+var tfs = {
+  linear: function linear(t) {
+    return t;
+  },
+  // eslint-disable-next-line
+  easeIn: function easeIn(t) {
+    return Math.pow(t, 1.675);
+  },
+  // eslint-disable-next-line
+  easeOut: function easeOut(t) {
+    return 1 - Math.pow(1 - t, 1.675);
+  },
+  easeInOut: function easeInOut(t) {
+    return 0.5 * (Math.sin((t - 0.5) * Math.PI) + 1);
+  }
+};
+/**
+ * Плавная прокрутка по горизонтали
+ * @param {Element} elem
+ * @param {number} pos
+ * @param {number} duration
+ * @param {string} timingFunction
+ */
+export var animatedScrollToX = function animatedScrollToX(elem, pos) {
+  var duration = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : DEFAULT_DURATION;
+  var timingFunction = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'easeInOut';
+  var startTime;
+  var startX = elem.scrollLeft;
+  var endX = Math.max(0, Math.min(elem.scrollWidth - elem.clientWidth, pos));
+  var handleNewAnimationFrame = function handleNewAnimationFrame() {
+    startTime = startTime || Date.now();
+    var timePos = Math.min(1, Math.max(1, Date.now() - startTime) / duration);
+    var scrollPos = tfs[timingFunction](timePos);
+    var left = startX + (endX - startX) * scrollPos;
+    elem.scrollTo({
+      left: left
+    });
+    if (timePos !== 1) window.requestAnimationFrame(handleNewAnimationFrame);
+  };
+  window.requestAnimationFrame(handleNewAnimationFrame);
+};
+
+/**
+ * Прокрутка к указанной позиции с анимацией или без.
+ */
+export var scrollToPos = function scrollToPos(_ref3) {
+  var scrollEl = _ref3.scrollEl,
+    pos = _ref3.pos,
+    animated = _ref3.animated,
+    duration = _ref3.duration,
+    timingFunction = _ref3.timingFunction;
+  if (Math.abs(pos - scrollEl.scrollLeft) > 1) {
+    if (animated) {
+      animatedScrollToX(scrollEl, pos, duration, timingFunction);
+    } else {
+      scrollEl.scrollTo({
+        left: pos
+      });
+    }
+  }
+};
+var round = function round(n) {
+  return Math.round(n * 100) / 100;
+};
+
+/**
+ * Получить позицию (слот) айтема в каруселе.
+ * Каждый айтем имеет свой слот относительно вьюпорта карусели.
+ */
+export var getItemSlot = function getItemSlot(itemIndex, itemEnd, itemSize, scrollStart, scrollSize, scrollAlign) {
+  var prevIndex = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : 0;
+  var offset = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : 0;
+  /**
+   * Граница и центр скролла (видимой части).
+   * Смещение + размер.
+   */
+  var scrollEnd = scrollStart + scrollSize;
+  var scrollCenter = scrollStart + scrollSize / 2;
+  var itemCenter = itemEnd - itemSize / 2;
+  if (scrollAlign === 'center') {
+    return round((itemCenter - scrollCenter) / itemSize);
+  }
+  if (scrollAlign === 'start') {
+    return round((itemEnd - itemSize - scrollStart) / itemSize);
+  }
+  if (scrollAlign === 'end') {
+    return round((itemEnd - (scrollSize + scrollStart)) / itemSize);
+  }
+  if (scrollAlign === 'activeDirection') {
+    var prevStart = offset + itemSize * prevIndex;
+    var prevEnd = prevStart + itemSize;
+    var prevVisible = prevEnd > scrollStart && prevStart < scrollEnd;
+    if (!prevVisible) {
+      if (prevIndex < itemIndex) {
+        return round((itemEnd - (scrollSize + scrollStart)) / itemSize);
+      }
+      return round((itemEnd - itemSize - scrollStart) / itemSize);
+    }
+  }
+  return null;
+};
+export function getCarouselItems(track) {
+  return track.children;
+}
+export function useDebouncedFunction(func, delay, cleanUp) {
+  var timeoutRef = useRef();
+
+  /**
+   * Очистка таймера
+   */
+  function clearTimer() {
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = undefined;
+    }
+  }
+
+  /**
+   * Очищаем таймер при анмаунте компонента, если cleanUp выставлен в true
+   * и тем самым отменяем последний запланированный вызов
+   */
+  useEffect(function () {
+    return cleanUp ? clearTimer : undefined;
+  }, [cleanUp]);
+  return function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    clearTimer();
+    timeoutRef.current = setTimeout(function () {
+      return func.apply(void 0, args);
+    }, delay);
+  };
+}
+var THROTTLE_DEFAULT_MS = 100;
+var DEBOUNCE_DEFAULT_MS = 150;
+export var useCarousel = function useCarousel(_ref4) {
+  var index = _ref4.index,
+    onIndexChange = _ref4.onIndexChange,
+    _ref4$detectActive = _ref4.detectActive,
+    detectActive = _ref4$detectActive === void 0 ? false : _ref4$detectActive,
+    _ref4$detectThreshold = _ref4.detectThreshold,
+    detectThreshold = _ref4$detectThreshold === void 0 ? 0.5 : _ref4$detectThreshold,
+    _ref4$scrollAlign = _ref4.scrollAlign,
+    scrollAlign = _ref4$scrollAlign === void 0 ? 'center' : _ref4$scrollAlign,
+    _ref4$throttleMs = _ref4.throttleMs,
+    throttleMs = _ref4$throttleMs === void 0 ? THROTTLE_DEFAULT_MS : _ref4$throttleMs,
+    _ref4$debounceMs = _ref4.debounceMs,
+    debounceMs = _ref4$debounceMs === void 0 ? DEBOUNCE_DEFAULT_MS : _ref4$debounceMs;
+  var prevIndex = useRef(null);
+  var offset = useRef(0);
+  var scrollRef = useRef(null);
+  var trackRef = useRef(null);
+  var axis = 'x';
+
+  /**
+   * Для того, чтобы не спамить изменениями индекса.
+   * Задержка дебаунса слегка больше, чем у тротлинга.
+   * Таким образом, событие срабатывает при завершении скролла.
+   */
+  var debouncedOnIndexChange = useDebouncedFunction(function (i) {
+    return onIndexChange === null || onIndexChange === void 0 ? void 0 : onIndexChange(i);
+  }, debounceMs);
+
+  /**
+   * Вычисление центрального элемента.
+   * Подсчет: от 0 до 1, какое количество ширины/высоты
+   * каждого элемента находится по центру скролла.
+   */
+  var throttledDetectActiveItem = useMemo(function () {
+    return throttle(function () {
+      if (!detectActive || scrollRef.current === null || trackRef.current === null) {
+        return;
+      }
+
+      /**
+       * Правая (или нижняя для Оу) граница элемента.
+       */
+      var itemEdge = offset.current;
+
+      /**
+       * Смещение (отрицательный или положительный отступ)
+       * и размер карусели (для Ox - ширина, для Oy - высота).
+       */
+      var scrollPos = scrollRef.current[axis === 'x' ? 'scrollLeft' : 'scrollTop'];
+      var scrollSize = scrollRef.current[axis === 'x' ? 'offsetWidth' : 'offsetHeight'];
+
+      /**
+       * Граница скролла (видимой части).
+       * Смещение + размер.
+       */
+      var scrollEdge = scrollPos + scrollSize;
+      var items = getCarouselItems(trackRef.current);
+
+      /**
+       * Проходим по всему списку, суммируя ширины элементов,
+       * пока не найдем один элемент, чей центр будет в центре карусели.
+       */
+      for (var itemIndex = 0; itemIndex < items.length; itemIndex++) {
+        var _prevIndex$current;
+        var item = items.item(itemIndex);
+        if (item === null) {
+          // eslint-disable-next-line no-continue
+          continue;
+        }
+
+        /**
+         * Для Ox - ширина, для Oy - высота.
+         */
+        var itemSize = item[axis === 'x' ? 'offsetWidth' : 'offsetHeight'];
+
+        /**
+         * Все элементы правее вьюпорта выпадают из процедуры.
+         * Сравниваем по предыдущему элементу.
+         * [ ... ] ...|n| <- Левый край элемента за пределами начала видимой части
+         */
+        if (itemEdge > scrollEdge) {
+          // eslint-disable-next-line no-continue
+          continue;
+        }
+        itemEdge += itemSize;
+
+        /**
+         * Все элементы левее вьюпорта выпадают из процедуры.
+         * Сравниваем по текущему элементу.
+         * Правый край элемента за пределами начала видимой части -> |p|... [ ... ]
+         */
+        if (scrollPos > itemEdge) {
+          // eslint-disable-next-line no-continue
+          continue;
+        }
+        var itemSlot = getItemSlot(itemIndex, itemEdge, itemSize, scrollPos, scrollSize, scrollAlign, (_prevIndex$current = prevIndex.current) !== null && _prevIndex$current !== void 0 ? _prevIndex$current : 0, offset.current);
+        if (itemSlot !== null) {
+          if (detectThreshold && Math.abs(itemSlot) <= detectThreshold) {
+            debouncedOnIndexChange === null || debouncedOnIndexChange === void 0 || debouncedOnIndexChange(itemIndex);
+          }
+        }
+      }
+    }, throttleMs);
+  }, [debouncedOnIndexChange, detectActive, detectThreshold, scrollAlign, throttleMs]);
+
+  /**
+   * Прокрутка до нужной позиции индекса.
+   */
+  var toIndex = useCallback(function (i) {
+    var scrollEl = scrollRef.current;
+    var items = trackRef.current ? getCarouselItems(trackRef.current) : null;
+    if (scrollEl && items && items.length > 0 && i >= 0) {
+      scrollToPos({
+        scrollEl: scrollEl,
+        pos: getCalculatedPos({
+          scrollEl: scrollEl,
+          items: items,
+          index: i,
+          offset: offset.current,
+          scrollAlign: scrollAlign
+        })
+      });
+      prevIndex.current = i;
+    }
+  }, [scrollAlign]);
+  useEffect(function () {
+    if (scrollRef.current && trackRef.current) {
+      offset.current = getCalculatedOffset(scrollRef.current, trackRef.current);
+    }
+  }, []);
+
+  /**
+   * Операции на маунте/анмаунте компонента.
+   * Создать слушатели событи и т.п.
+   */
+  useEffect(function () {
+    var carouselElement = scrollRef.current;
+    if (carouselElement) {
+      carouselElement.addEventListener('scroll', throttledDetectActiveItem);
+    }
+    return function () {
+      if (carouselElement) {
+        carouselElement.removeEventListener('scroll', throttledDetectActiveItem);
+      }
+    };
+  }, [throttledDetectActiveItem]);
+
+  /**
+   * Прокрутка до нужной позиции индекса, если индекс изменился.
+   */
+  useEffect(function () {
+    if (index !== prevIndex.current) {
+      toIndex(index);
+    }
+  }, [index, toIndex]);
+  return {
+    scrollRef: scrollRef,
+    trackRef: trackRef
+  };
+};

package/emotion/es/components/Carousel/CarouselNew/ui/Dots/Dots.js

@@ -0,0 +1,219 @@
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+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 _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+import React, { memo, useRef, useLayoutEffect } from 'react';
+import cls from 'classnames';
+import { useDidMountLayoutEffect } from "../../../../../hooks";
+import { classes } from "../../Carousel.tokens";
+import { getActiveIndex, getTargetIndex, getInitialData } from "./utils/index";
+import { Wrapper, DotWrapper, RightAnimationWrapper, LeftAnimationWrapper, TransitionWrapper } from "./Dots.styles";
+var SIZE = 16; // размер точки в px
+var ANIMATION_DURATION = 0.3; // скорость анимации в секундах
+
+export var Dots = /*#__PURE__*/memo(function (_ref) {
+  var _ref$index = _ref.index,
+    originalIndex = _ref$index === void 0 ? 0 : _ref$index,
+    onChange = _ref.onChange,
+    _ref$centered = _ref.centered,
+    centered = _ref$centered === void 0 ? false : _ref$centered,
+    _ref$count = _ref.count,
+    count = _ref$count === void 0 ? 0 : _ref$count,
+    _ref$visibleCount = _ref.visibleCount,
+    originalVisibleCount = _ref$visibleCount === void 0 ? 0 : _ref$visibleCount;
+  // Трансформируем входные параметры для корректной работы в дальнейшем
+  var _getInitialData = getInitialData(originalIndex, count, originalVisibleCount),
+    _getInitialData2 = _slicedToArray(_getInitialData, 2),
+    index = _getInitialData2[0],
+    visibleCount = _getInitialData2[1];
+
+  // Рефки на DOM-ноды
+  var transitionWrapperRef = useRef(null);
+  var dotWrapperRef = useRef(null);
+  var leftAnimationWrapperRef = useRef(null);
+  var rightAnimationWrapperRef = useRef(null);
+
+  // Консистентные переменные
+  var isAnimating = useRef(false);
+  var prevIndex = useRef(-Infinity);
+  var prevActiveIndex = useRef(Infinity);
+  var isRightDirection = index > prevIndex.current;
+  var diffDotsRange = Math.abs(index - prevIndex.current);
+  var activeIndex = getActiveIndex(index, isRightDirection, count, visibleCount);
+  var hiddenDotsLeft = activeIndex < index;
+  var hiddenDotsRight = index + (visibleCount - 1 - activeIndex) < count - 1;
+  var handleClick = function handleClick(i) {
+    if (isAnimating.current) return;
+    if (onChange) {
+      onChange(index + (i - activeIndex));
+    }
+  };
+  var handleTransitionEnd = function handleTransitionEnd() {
+    if (!dotWrapperRef || !dotWrapperRef.current || !transitionWrapperRef || !transitionWrapperRef.current || !rightAnimationWrapperRef || !rightAnimationWrapperRef.current || !leftAnimationWrapperRef || !leftAnimationWrapperRef.current) {
+      return;
+    }
+    dotWrapperRef.current.classList.remove(classes.animating);
+    transitionWrapperRef.current.classList.remove(classes.animating);
+    Array.from(dotWrapperRef.current.children).forEach(function (child) {
+      var _child$classList;
+      (_child$classList = child.classList).remove.apply(_child$classList, [classes.active, classes.animateOut, classes.temporaryNatural, classes.shrinking]);
+    });
+    dotWrapperRef.current.children[activeIndex].classList.add(classes.active);
+    if (centered) {
+      transitionWrapperRef.current.style.transform = "translateX(".concat(visibleCount * SIZE / 2 - SIZE / 2 - activeIndex * SIZE, "px)");
+    } else {
+      transitionWrapperRef.current.style.transform = 'translateX(0)';
+    }
+    setTimeout(function () {
+      if (transitionWrapperRef && transitionWrapperRef.current) {
+        isAnimating.current = false;
+      }
+    });
+
+    // Очищаем блоки с анимированными точками
+    leftAnimationWrapperRef.current.innerText = '';
+    rightAnimationWrapperRef.current.innerText = '';
+    prevIndex.current = index;
+    prevActiveIndex.current = activeIndex;
+    isAnimating.current = false;
+  };
+  useLayoutEffect(function () {
+    if (!dotWrapperRef || !dotWrapperRef.current || !transitionWrapperRef || !transitionWrapperRef.current) {
+      return;
+    }
+
+    // Вычисляем начальный сдвиг по горизонтали, чтобы точка стала по центру
+    if (centered) {
+      transitionWrapperRef.current.style.transform = "translateX(".concat(visibleCount * SIZE / 2 - SIZE / 2 - activeIndex * SIZE, "px)");
+    }
+    prevIndex.current = index;
+    prevActiveIndex.current = activeIndex;
+  }, []);
+  useDidMountLayoutEffect(function () {
+    var _dotWrapperRef$curren;
+    if (!dotWrapperRef || !dotWrapperRef.current || !transitionWrapperRef || !transitionWrapperRef.current || !leftAnimationWrapperRef || !leftAnimationWrapperRef.current || !rightAnimationWrapperRef || !rightAnimationWrapperRef.current || isAnimating.current) {
+      return;
+    }
+    isAnimating.current = true;
+    dotWrapperRef.current.classList.add(classes.animating);
+    transitionWrapperRef.current.classList.add(classes.animating);
+    var targetIndex = getTargetIndex(index, prevIndex.current, prevActiveIndex.current, diffDotsRange);
+    var dotsToAdd = Math.abs(targetIndex - activeIndex);
+    if (centered) {
+      transitionWrapperRef.current.style.transform = "translateX(".concat(visibleCount * SIZE / 2 - SIZE / 2 - targetIndex * SIZE, "px)");
+    } else if (dotsToAdd > 0) {
+      transitionWrapperRef.current.style.transform = "translateX(".concat(-SIZE * (targetIndex - activeIndex), "px)");
+    }
+
+    // Стираем все активные классы и устанавливаем активный класс на таргет.
+    // В конце анимации произойдет переопределение активного класса.
+    Array.from(dotWrapperRef.current.children).forEach(function (child) {
+      child.classList.remove(classes.active);
+    });
+    (_dotWrapperRef$curren = dotWrapperRef.current.children[targetIndex]) === null || _dotWrapperRef$curren === void 0 || _dotWrapperRef$curren.classList.add(classes.active);
+    if (index > prevIndex.current) {
+      // Двигаемся вправо
+
+      // Если мы добавляем 1 и более точек, то нужно начать
+      // приводить размер крайней правой точки (что будет в m размере?)
+      // к натуральному размеру
+      if (dotsToAdd >= 1) {
+        var _dotWrapperRef$curren2;
+        (_dotWrapperRef$curren2 = dotWrapperRef.current.children[visibleCount - 1]) === null || _dotWrapperRef$curren2 === void 0 || _dotWrapperRef$curren2.classList.add(classes.temporaryNatural);
+      }
+
+      // Т.к. мы двигаемся вправо, то нужно начать уменьшать размер крайней левой точки
+      // (опять же, что в m size?)
+      if (dotsToAdd >= 1) {
+        var _dotWrapperRef$curren3;
+        (_dotWrapperRef$curren3 = dotWrapperRef.current.children[dotsToAdd]) === null || _dotWrapperRef$curren3 === void 0 || _dotWrapperRef$curren3.classList.add(classes.shrinking);
+      }
+      if (dotsToAdd > 0) {
+        var _loop = function _loop() {
+          var _dotWrapperRef$curren4;
+          var node = document.createElement('div');
+          node.textContent = '';
+          node.classList.add(classes.dot);
+          node.style.opacity = '0';
+          var delay = i * (ANIMATION_DURATION / dotsToAdd);
+          node.style.animationDelay = "".concat(delay, "s");
+          rightAnimationWrapperRef.current.appendChild(node);
+          var duration = ANIMATION_DURATION / dotsToAdd;
+          requestAnimationFrame(function () {
+            node.classList.add(classes.animateIn);
+            node.style.animationDuration = "".concat(duration, "s");
+          });
+          var currentDomNode = (_dotWrapperRef$curren4 = dotWrapperRef.current.children) === null || _dotWrapperRef$curren4 === void 0 ? void 0 : _dotWrapperRef$curren4[i];
+          currentDomNode === null || currentDomNode === void 0 || currentDomNode.classList.add(classes.animateOut);
+          currentDomNode.style.animationDelay = "".concat(delay, "s");
+          currentDomNode.style.animationDuration = "".concat(duration, "s");
+        };
+        for (var i = 0; i < dotsToAdd; i++) {
+          _loop();
+        }
+      }
+    } else {
+      // Двигаемся влево
+
+      // Если мы добавляем 1 и более точек, то нужно начать
+      // приводить размер крайней левой точки (что будет в m размере?)
+      // к натуральному размеру.
+      if (dotsToAdd >= 1) {
+        var _dotWrapperRef$curren5;
+        (_dotWrapperRef$curren5 = dotWrapperRef.current.children[0]) === null || _dotWrapperRef$curren5 === void 0 || _dotWrapperRef$curren5.classList.add(classes.temporaryNatural);
+      }
+
+      // Т.к. мы двигаемся влево, то нужно начать уменьшать размер крайней правой точки
+      // (опять же, что в m size?)
+      if (dotsToAdd >= 1) {
+        var _dotWrapperRef$curren6;
+        (_dotWrapperRef$curren6 = dotWrapperRef.current.children[visibleCount - 1 - dotsToAdd]) === null || _dotWrapperRef$curren6 === void 0 || _dotWrapperRef$curren6.classList.add(classes.shrinking);
+      }
+      if (dotsToAdd > 0) {
+        var _loop2 = function _loop2() {
+          var _dotWrapperRef$curren7;
+          var node = document.createElement('div');
+          node.textContent = '';
+          node.classList.add(classes.dot);
+          node.style.opacity = '0';
+          var delay = (dotsToAdd - 1 - _i) * (ANIMATION_DURATION / dotsToAdd);
+          node.style.animationDelay = "".concat(delay, "s");
+          leftAnimationWrapperRef.current.prepend(node);
+          var duration = ANIMATION_DURATION / dotsToAdd;
+          requestAnimationFrame(function () {
+            node.classList.add(classes.animateIn);
+            node.style.animationDuration = "".concat(duration, "s");
+          });
+          var currentDomNode = (_dotWrapperRef$curren7 = dotWrapperRef.current.children) === null || _dotWrapperRef$curren7 === void 0 ? void 0 : _dotWrapperRef$curren7[dotWrapperRef.current.children.length - 1 - _i];
+          currentDomNode === null || currentDomNode === void 0 || currentDomNode.classList.add(classes.animateOut);
+          currentDomNode.style.animationDelay = "".concat(_i * (ANIMATION_DURATION / dotsToAdd), "s");
+          currentDomNode.style.animationDuration = "".concat(duration, "s");
+        };
+        for (var _i = dotsToAdd - 1; _i >= 0; _i--) {
+          _loop2();
+        }
+      }
+    }
+  }, [index]);
+  return /*#__PURE__*/React.createElement(Wrapper, null, /*#__PURE__*/React.createElement(TransitionWrapper, {
+    ref: transitionWrapperRef,
+    onTransitionEnd: handleTransitionEnd
+  }, /*#__PURE__*/React.createElement(LeftAnimationWrapper, {
+    ref: leftAnimationWrapperRef
+  }), /*#__PURE__*/React.createElement(DotWrapper, {
+    ref: dotWrapperRef,
+    className: cls(hiddenDotsLeft && classes.availableDotsLeft, hiddenDotsRight && classes.availableDotsRight)
+  }, Array(visibleCount).fill(0).map(function (_, i) {
+    return /*#__PURE__*/React.createElement("div", {
+      key: i,
+      className: cls(classes.dot, i === activeIndex && classes.active),
+      onClick: function onClick() {
+        return handleClick(i);
+      }
+    });
+  })), /*#__PURE__*/React.createElement(RightAnimationWrapper, {
+    ref: rightAnimationWrapperRef
+  })));
+});