@salutejs/plasma-new-hope 0.322.0-canary.1944.14662885061.0 → 0.322.0-canary.1947.14664713311.0

package/emotion/es/components/PaginationDots/PaginationDots.js

@@ -0,0 +1,311 @@
+var _excluded = ["view", "size", "activeElementView", "orientation", "centered", "value", "count", "visibleCount", "onChange"];
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+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; }
+function _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var n = Object.getOwnPropertySymbols(e); for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; }
+function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; }
+import React, { forwardRef, useEffect, useLayoutEffect, useRef, useState } from 'react';
+import cls from 'classnames';
+import { useForkRef } from '@salutejs/plasma-core';
+import { usePreviousValue } from "../../hooks";
+import { base as viewCSS } from "../PaginationDots/variations/_view/base";
+import { base as sizeCSS } from "../PaginationDots/variations/_size/base";
+import { AnimatedDotsWrapper, base, Dot, Line, Wrapper } from "./PaginationDots.styles";
+import { classes } from "./PaginationDots.tokens";
+import { getDotSize } from "./utils/getDotSize";
+import { useAnimation } from "./hooks/useAnimation";
+var sizesMap = {
+  xs: 18,
+  s: 20,
+  m: 24
+};
+var getInitialOffset = function getInitialOffset(value, visibleCount, count) {
+  var middle = Math.floor(visibleCount / 2);
+  if (value < middle) {
+    return 0;
+  }
+  if (count - value <= middle) {
+    return count - visibleCount;
+  }
+  return value - middle;
+};
+export var getVisualOffsets = function getVisualOffsets(dots, innerViewValue) {
+  var before = dots.slice(0, innerViewValue).reduce(function (acc, size) {
+    return acc + sizesMap[size];
+  }, 0);
+  var after = dots.slice(innerViewValue + 1).reduce(function (acc, size) {
+    return acc + sizesMap[size];
+  }, 0);
+  return (after - before) / 2;
+};
+var getFirstAnimatedDotsOffset = function getFirstAnimatedDotsOffset(dots, prevDots) {
+  var sizeBefore = sizesMap[prevDots[0]];
+  var sizeAfter = sizesMap[dots[0]];
+  return sizeBefore - sizeAfter;
+};
+var getLastAnimatedDotsOffset = function getLastAnimatedDotsOffset(dots, prevDots) {
+  var sizeBefore = sizesMap[prevDots[prevDots.length - 1]];
+  var sizeAfter = sizesMap[dots[dots.length - 1]];
+  return sizeBefore - sizeAfter;
+};
+
+/*
+        (m) m m s xs  value: 0, offset: 0
+      m (m) m s xs    value: 1, offset: 0
+    m m (m) s xs      value: 2, offset: 0
+    s m (m) s xs      value: 3, offset: 1
+   xs s (m) s xs      value: 4, offset: 2
+
+ */
+
+var isDebug = false;
+export var paginationDotsRoot = function paginationDotsRoot(Root) {
+  return /*#__PURE__*/forwardRef(function (_ref, outerRef) {
+    var view = _ref.view,
+      size = _ref.size,
+      _ref$activeElementVie = _ref.activeElementView,
+      activeElementView = _ref$activeElementVie === void 0 ? 'dot' : _ref$activeElementVie,
+      _ref$orientation = _ref.orientation,
+      orientation = _ref$orientation === void 0 ? 'horizontal' : _ref$orientation,
+      _ref$centered = _ref.centered,
+      centered = _ref$centered === void 0 ? false : _ref$centered,
+      _ref$value = _ref.value,
+      value = _ref$value === void 0 ? 0 : _ref$value,
+      _ref$count = _ref.count,
+      count = _ref$count === void 0 ? 0 : _ref$count,
+      visibleCount = _ref.visibleCount,
+      onChange = _ref.onChange,
+      rest = _objectWithoutProperties(_ref, _excluded);
+    var innerRef = useRef(null);
+    var wrapperRef = useRef(null);
+    var activeElementRef = useRef(null);
+    var animatedDotsWrapperRef = useRef(null);
+    useForkRef(outerRef, innerRef);
+    var innerValue = Math.min(value, count - 1);
+    var innerVisibleCount = Math.min(visibleCount || count, count);
+    var isLineView = activeElementView === 'line';
+    var isVertical = orientation === 'vertical';
+    var hasScroll = innerVisibleCount < count;
+    var _useState = useState(innerValue),
+      _useState2 = _slicedToArray(_useState, 2),
+      currentValue = _useState2[0],
+      setCurrentValue = _useState2[1];
+    var _useState3 = useState(),
+      _useState4 = _slicedToArray(_useState3, 2),
+      prevValue = _useState4[0],
+      setPrevValue = _useState4[1];
+    var _useState5 = useState(function () {
+        return getInitialOffset(innerValue, innerVisibleCount, count);
+      }),
+      _useState6 = _slicedToArray(_useState5, 2),
+      offset = _useState6[0],
+      setOffset = _useState6[1];
+    var prevOffset = usePreviousValue(offset);
+    var prevDotsRef = useRef([]);
+    var dots = new Array(innerVisibleCount).fill(null).map(function (_, index) {
+      return getDotSize(size, index + offset, offset, count, innerVisibleCount);
+    });
+    var setVisualOffset = function setVisualOffset(currentValueNew, newOffset) {
+      var innerViewValue = currentValueNew - newOffset;
+
+      // canScrollBackward || canScrollForward
+      var withAnimation = centered ? true : newOffset !== offset;
+      if (!animatedDotsWrapperRef.current || !withAnimation) {
+        if (wrapperRef.current) {
+          wrapperRef.current.style.transform = 'none';
+        }
+        return;
+      }
+      var visualOffset = getVisualOffsets(dots, innerViewValue);
+      if (wrapperRef.current) {
+        wrapperRef.current.style.transform = isVertical ? "translateY(".concat(visualOffset, "px)") : "translateX(".concat(visualOffset, "px)");
+      }
+    };
+    if (isDebug) {
+      console.log('!!!', JSON.stringify({
+        prevValue: prevValue,
+        prevOffset: prevOffset,
+        value: innerValue,
+        offset: offset
+      }));
+    }
+    var canScrollForward = prevValue !== undefined ? !!offset && count - innerVisibleCount > prevOffset : false;
+    var canScrollBackward = Boolean(prevOffset && offset + innerVisibleCount !== count);
+    var _useAnimation = useAnimation({
+        innerViewIndex: currentValue - offset,
+        dots: dots,
+        prevDots: prevDotsRef.current,
+        canScrollBackward: canScrollBackward,
+        canScrollForward: canScrollForward,
+        isVertical: isVertical,
+        activeElementRef: activeElementRef,
+        animatedDotsWrapperRef: animatedDotsWrapperRef,
+        onAnimationEnd: function onAnimationEnd() {
+          console.log('!!! onAnimationEnd');
+          var newOffset = getInitialOffset(innerValue, innerVisibleCount, count);
+          setOffset(newOffset);
+          setPrevValue(undefined);
+          setSkipAnimation(true);
+        }
+      }),
+      skipAnimation = _useAnimation.skipAnimation,
+      hasAnimation = _useAnimation.hasAnimation,
+      hasForwardAnimation = _useAnimation.hasForwardAnimation,
+      hasBackwardAnimation = _useAnimation.hasBackwardAnimation,
+      setSkipAnimation = _useAnimation.setSkipAnimation,
+      setHasForwardAnimation = _useAnimation.setHasForwardAnimation,
+      setHasBackwardAnimation = _useAnimation.setHasBackwardAnimation,
+      handleAnimationEnd = _useAnimation.handleAnimationEnd;
+    var hasAnimatedDot = hasAnimation && innerVisibleCount > 2 && (hasBackwardAnimation && canScrollBackward || hasForwardAnimation && canScrollForward);
+    var calcOffset = function calcOffset(currentValue, prevValue) {
+      if (prevValue === undefined || centered && !hasScroll) {
+        return;
+      }
+      var toFront = currentValue > prevValue;
+      var toBack = currentValue < prevValue;
+      var newOffset = getInitialOffset(currentValue, innerVisibleCount, count);
+      var withAnimation = centered ? true : newOffset !== offset;
+      if (toFront) {
+        if (withAnimation) {
+          setHasForwardAnimation(true);
+          prevDotsRef.current = _toConsumableArray(dots);
+          setOffset(newOffset);
+        } else {
+          setOffset(newOffset);
+        }
+      } else if (toBack) {
+        if (withAnimation) {
+          setHasBackwardAnimation(true);
+          prevDotsRef.current = _toConsumableArray(dots);
+          setOffset(newOffset);
+        } else {
+          setOffset(newOffset);
+        }
+      }
+    };
+    useLayoutEffect(function () {
+      setVisualOffset(innerValue, offset);
+    }, [isVertical, centered]);
+    useLayoutEffect(function () {
+      if (prevValue === undefined) {
+        setVisualOffset(innerValue, offset);
+        if (animatedDotsWrapperRef.current) {
+          animatedDotsWrapperRef.current.style.transition = 'none';
+          animatedDotsWrapperRef.current.style.transform = 'none';
+        }
+      }
+    }, [innerValue, offset, prevValue]);
+    useLayoutEffect(function () {
+      setSkipAnimation(true);
+      setPrevValue(undefined);
+    }, [count, innerVisibleCount, isVertical, isLineView, hasScroll]);
+    useEffect(function () {
+      // setSkipAnimation(true);
+      // setPrevValue(undefined);
+    }, []);
+    var onMove = function onMove(newValue) {
+      setSkipAnimation(false);
+      calcOffset(newValue, currentValue);
+      setCurrentValue(newValue);
+      setPrevValue(currentValue);
+      onChange === null || onChange === void 0 || onChange(newValue);
+    };
+    if (!innerVisibleCount || innerVisibleCount <= 0) {
+      return null;
+    }
+    var dotsNodes = dots.map(function (dotSize, viewIndex) {
+      var dotIndex = viewIndex + offset;
+      var isCurrent = dotIndex === currentValue;
+      var isClickable = dotIndex === currentValue - 1 || dotIndex === currentValue + 1;
+      var onClick = isClickable && !hasAnimation ? function () {
+        return onMove(dotIndex);
+      } : undefined;
+      if (isCurrent) {
+        var ActiveElement = activeElementView === 'dot' ? Dot : Line;
+        return /*#__PURE__*/React.createElement(ActiveElement, {
+          key: viewIndex,
+          ref: activeElementRef,
+          "data-size": size,
+          "data-view": activeElementView,
+          className: cls(classes.active, isVertical && classes.vertical, skipAnimation && classes.skipAnimation)
+        }, isDebug ? dotIndex : null);
+      }
+      var isPrevActive = prevValue === dotIndex;
+      var innerViewValue = dotIndex - offset;
+      var isFirst = innerViewValue === 0;
+      var isLast = innerViewValue === innerVisibleCount - 1;
+      return /*#__PURE__*/React.createElement(Dot, {
+        key: viewIndex,
+        className: cls(isVertical && classes.vertical, isClickable && classes.clickable, isPrevActive && classes.prevActive, skipAnimation && classes.skipAnimation),
+        style: {
+          visibility: isLast && hasForwardAnimation && canScrollForward || isFirst && hasBackwardAnimation && canScrollBackward ? 'hidden' : 'visible'
+        },
+        "data-size": dotSize,
+        "data-view": activeElementView,
+        onClick: onClick
+      }, isDebug ? dotIndex : null);
+    });
+    return /*#__PURE__*/React.createElement(Root, _extends({
+      size: size,
+      view: view,
+      className: cls(centered && classes.centered, isVertical && classes.vertical),
+      ref: innerRef
+    }, rest), /*#__PURE__*/React.createElement(Wrapper, {
+      ref: wrapperRef,
+      "data-size": size
+    }, hasAnimatedDot && /*#__PURE__*/React.createElement(Dot, {
+      className: cls(isVertical && classes.vertical, {
+        hidden: hasForwardAnimation,
+        showed: hasBackwardAnimation
+      }),
+      "data-view": activeElementView,
+      "data-size": dots[0],
+      style: isVertical ? {
+        top: "".concat(getFirstAnimatedDotsOffset(dots, prevDotsRef.current), "px")
+      } : {
+        left: "".concat(getFirstAnimatedDotsOffset(dots, prevDotsRef.current), "px")
+      }
+    }, isDebug ? offset + (hasForwardAnimation ? -1 : 0) : null), /*#__PURE__*/React.createElement(AnimatedDotsWrapper, {
+      ref: animatedDotsWrapperRef,
+      onTransitionEnd: handleAnimationEnd
+    }, dotsNodes), hasAnimatedDot && /*#__PURE__*/React.createElement(Dot, {
+      className: cls(isVertical && classes.vertical, {
+        hidden: hasBackwardAnimation,
+        showed: hasForwardAnimation
+      }),
+      "data-view": activeElementView,
+      "data-size": dots[dots.length - 1],
+      style: isVertical ? {
+        bottom: "".concat(getLastAnimatedDotsOffset(dots, prevDotsRef.current), "px")
+      } : {
+        right: "".concat(getLastAnimatedDotsOffset(dots, prevDotsRef.current), "px")
+      }
+    }, isDebug ? offset + innerVisibleCount + (hasForwardAnimation ? -1 : 0) : null)));
+  });
+};
+export var paginationDotsConfig = {
+  name: 'PaginationDots',
+  tag: 'div',
+  layout: paginationDotsRoot,
+  base: base,
+  variations: {
+    view: {
+      css: viewCSS
+    },
+    size: {
+      css: sizeCSS
+    }
+  },
+  defaults: {
+    view: 'default',
+    size: 'm'
+  }
+};

package/emotion/es/components/PaginationDots/PaginationDots.styles.js

@@ -0,0 +1,37 @@
+import _styled from "@emotion/styled/base";
+function _EMOTION_STRINGIFIED_CSS_ERROR__() { return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop)."; }
+import { css } from '@emotion/react';
+import { classes, tokens } from "./PaginationDots.tokens";
+export var Wrapper = /*#__PURE__*/_styled("div", {
+  target: "e95px8o3",
+  label: "plasma-new-hope__Wrapper"
+})(process.env.NODE_ENV === "production" ? {
+  name: "dxkoxo",
+  styles: "position:relative;display:flex;align-items:center;justify-content:center"
+} : {
+  name: "dxkoxo",
+  styles: "position:relative;display:flex;align-items:center;justify-content:center",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src-emotion/components/PaginationDots/PaginationDots.styles.ts"],"names":[],"mappings":"AAKiC","file":"../../../../src-emotion/components/PaginationDots/PaginationDots.styles.ts","sourcesContent":["import { css } from '@emotion/react';\nimport styled from '@emotion/styled';\n\nimport { classes, tokens } from './PaginationDots.tokens';\n\nexport const Wrapper = styled.div`\n    position: relative;\n    display: flex;\n    align-items: center;\n    justify-content: center;\n`;\n\nexport const AnimatedDotsWrapper = styled.div`\n    display: flex;\n    align-items: center;\n    justify-content: center;\n`;\n\nexport const Dot = styled.div`\n    box-sizing: border-box;\n    padding: var(${tokens.dotPadding});\n\n    &:before {\n        content: '';\n        display: block;\n        border-radius: var(${tokens.dotBorderRadius});\n        background-color: var(${tokens.itemBackground});\n        transition: width 0.3s linear, height 0.3s linear;\n    }\n\n    &.${classes.active} {\n        &:before {\n            background-color: var(${tokens.activeItemBackground});\n        }\n    }\n\n    &[data-size='xs'] {\n        &:before {\n            --plasma-private-dot-size: var(${tokens.dotSizeXS});\n            width: var(${tokens.dotSizeXS});\n            height: var(${tokens.dotSizeXS});\n        }\n    }\n\n    &[data-size='s'] {\n        &:before {\n            --plasma-private-dot-size: var(${tokens.dotSizeS});\n            width: var(${tokens.dotSizeS});\n            height: var(${tokens.dotSizeS});\n        }\n    }\n\n    &[data-size='m'] {\n        &:before {\n            --plasma-private-dot-size: var(${tokens.dotSizeM});\n            width: var(${tokens.dotSizeM});\n            height: var(${tokens.dotSizeM});\n        }\n    }\n\n    &.${classes.clickable} {\n        cursor: pointer;\n    }\n\n    @keyframes showAnimation {\n        from {\n            transform: scale(0);\n            opacity: 0;\n        }\n        to {\n            transform: scale(1);\n            opacity: 1;\n        }\n    }\n\n    @keyframes showWithColor {\n        from {\n            background-color: var(${tokens.itemBackground});\n        }\n        to {\n            background-color: var(${tokens.activeItemBackground});\n        }\n    }\n\n    @keyframes hideWithColor {\n        from {\n            background-color: var(${tokens.activeItemBackground});\n        }\n        to {\n            background-color: var(${tokens.itemBackground});\n        }\n    }\n\n    @keyframes hideAnimation {\n        from {\n            transform: scale(1);\n            opacity: 1;\n        }\n        to {\n            transform: scale(0);\n            opacity: 0;\n        }\n    }\n\n    @keyframes reversedWidthAnimation {\n        from {\n            width: var(${tokens.lineWidth});\n            height: var(${tokens.lineHeight});\n            border-radius: var(${tokens.lineBorderRadius});\n            background-color: var(${tokens.activeItemBackground});\n        }\n        to {\n            width: var(--plasma-private-dot-size);\n            height: var(--plasma-private-dot-size);\n            border-radius: var(${tokens.lineBorderRadius});\n            background-color: var(${tokens.itemBackground});\n        }\n    }\n\n    @keyframes reversedHeightAnimation {\n        from {\n            width: var(${tokens.verticalLineWidth});\n            height: var(${tokens.verticalLineHeight});\n            border-radius: var(${tokens.lineBorderRadius});\n        }\n        to {\n            width: var(--plasma-private-dot-size);\n            height: var(--plasma-private-dot-size);\n            border-radius: var(${tokens.lineBorderRadius});\n        }\n    }\n\n    &.${classes.prevActive} {\n        &[data-view='line'] {\n            &:before {\n                animation-name: reversedWidthAnimation;\n                animation-duration: 0.3s;\n                animation-iteration-count: 1;\n                animation-play-state: running;\n                animation-timing-function: linear;\n            }\n\n            &.${classes.vertical} {\n                &:before {\n                    animation-name: reversedHeightAnimation;\n                }\n            }\n        }\n\n        &[data-view='dot'] {\n            &:before {\n                animation-name: hideWithColor;\n                animation-duration: 0.3s;\n                animation-iteration-count: 1;\n                animation-play-state: running;\n                animation-timing-function: linear;\n                animation-timing-function: ease-out;\n            }\n        }\n    }\n\n    &.hidden {\n        position: absolute;\n        animation-name: hideAnimation;\n        animation-duration: calc(0.3s + 0.1s);\n        animation-iteration-count: 1;\n        animation-play-state: running;\n        animation-timing-function: linear;\n    }\n\n    &.showed {\n        position: absolute;\n        animation-name: showAnimation;\n        animation-duration: 0.3s;\n        animation-iteration-count: 1;\n        animation-play-state: running;\n        animation-timing-function: linear;\n    }\n\n    &.${classes.active} {\n        &[data-view='dot'] {\n            &:before {\n                animation-name: showWithColor;\n                animation-duration: 0.3s;\n                animation-iteration-count: 1;\n                animation-play-state: running;\n                animation-timing-function: linear;\n                animation-timing-function: ease-in;\n            }\n        }\n    }\n\n    &.${classes.skipAnimation} {\n        transition: none;\n        animation-name: none !important;\n\n        &:before {\n            transition: none;\n            animation-name: none !important;\n        }\n    }\n`;\n\nexport const Line = styled(Dot)`\n    @keyframes widthAnimation {\n        from {\n            width: var(${tokens.lineHeight});\n            height: var(${tokens.lineHeight});\n            background-color: var(${tokens.itemBackground});\n        }\n        to {\n            width: var(${tokens.lineWidth});\n            height: var(${tokens.lineHeight});\n            background-color: var(${tokens.activeItemBackground});\n        }\n    }\n\n    @keyframes heightAnimation {\n        from {\n            width: var(${tokens.lineHeight});\n            height: var(${tokens.lineHeight});\n            background-color: var(${tokens.itemBackground});\n        }\n        to {\n            width: var(${tokens.verticalLineWidth});\n            height: var(${tokens.verticalLineHeight});\n            background-color: var(${tokens.activeItemBackground});\n        }\n    }\n\n    &[data-size='s'] {\n        &:before {\n            width: var(${tokens.lineWidth});\n            height: var(${tokens.lineHeight});\n            border-radius: var(${tokens.lineBorderRadius});\n        }\n    }\n\n    &[data-size='m'] {\n        &:before {\n            width: var(${tokens.lineWidth});\n            height: var(${tokens.lineHeight});\n            border-radius: var(${tokens.lineBorderRadius});\n        }\n    }\n\n    &.${classes.vertical} {\n        &[data-size='s'] {\n            &:before {\n                width: var(${tokens.verticalLineWidth});\n                height: var(${tokens.verticalLineHeight});\n            }\n        }\n\n        &[data-size='m'] {\n            &:before {\n                width: var(${tokens.verticalLineWidth});\n                height: var(${tokens.verticalLineHeight});\n            }\n        }\n    }\n\n    &.${classes.active} {\n        &:before {\n            animation-name: widthAnimation;\n            animation-duration: 0.3s;\n            animation-iteration-count: 1;\n            animation-play-state: running;\n            animation-timing-function: linear;\n        }\n\n        &.${classes.vertical} {\n            &:before {\n                animation-name: heightAnimation;\n            }\n        }\n    }\n\n    &.${classes.skipAnimation} {\n        animation-name: none !important;\n\n        &:before {\n            animation-name: none !important;\n        }\n    }\n`;\n\nexport const base = css`\n    display: flex;\n    align-items: center;\n    justify-content: flex-start;\n\n    &.${classes.centered} {\n        width: 100%;\n        justify-content: center;\n    }\n\n    &.${classes.vertical} {\n        display: inline-flex;\n        flex-direction: column;\n        align-items: center;\n\n        ${Dot} {\n            padding: var(${tokens.verticalDotPadding});\n        }\n\n        ${AnimatedDotsWrapper} {\n            flex-direction: column;\n        }\n\n        &.${classes.centered} {\n            width: auto;\n            height: 100%;\n\n            position: relative;\n        }\n    }\n`;\n"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});
+export var AnimatedDotsWrapper = /*#__PURE__*/_styled("div", {
+  target: "e95px8o2",
+  label: "plasma-new-hope__AnimatedDotsWrapper"
+})(process.env.NODE_ENV === "production" ? {
+  name: "1wnowod",
+  styles: "display:flex;align-items:center;justify-content:center"
+} : {
+  name: "1wnowod",
+  styles: "display:flex;align-items:center;justify-content:center",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src-emotion/components/PaginationDots/PaginationDots.styles.ts"],"names":[],"mappings":"AAY6C","file":"../../../../src-emotion/components/PaginationDots/PaginationDots.styles.ts","sourcesContent":["import { css } from '@emotion/react';\nimport styled from '@emotion/styled';\n\nimport { classes, tokens } from './PaginationDots.tokens';\n\nexport const Wrapper = styled.div`\n    position: relative;\n    display: flex;\n    align-items: center;\n    justify-content: center;\n`;\n\nexport const AnimatedDotsWrapper = styled.div`\n    display: flex;\n    align-items: center;\n    justify-content: center;\n`;\n\nexport const Dot = styled.div`\n    box-sizing: border-box;\n    padding: var(${tokens.dotPadding});\n\n    &:before {\n        content: '';\n        display: block;\n        border-radius: var(${tokens.dotBorderRadius});\n        background-color: var(${tokens.itemBackground});\n        transition: width 0.3s linear, height 0.3s linear;\n    }\n\n    &.${classes.active} {\n        &:before {\n            background-color: var(${tokens.activeItemBackground});\n        }\n    }\n\n    &[data-size='xs'] {\n        &:before {\n            --plasma-private-dot-size: var(${tokens.dotSizeXS});\n            width: var(${tokens.dotSizeXS});\n            height: var(${tokens.dotSizeXS});\n        }\n    }\n\n    &[data-size='s'] {\n        &:before {\n            --plasma-private-dot-size: var(${tokens.dotSizeS});\n            width: var(${tokens.dotSizeS});\n            height: var(${tokens.dotSizeS});\n        }\n    }\n\n    &[data-size='m'] {\n        &:before {\n            --plasma-private-dot-size: var(${tokens.dotSizeM});\n            width: var(${tokens.dotSizeM});\n            height: var(${tokens.dotSizeM});\n        }\n    }\n\n    &.${classes.clickable} {\n        cursor: pointer;\n    }\n\n    @keyframes showAnimation {\n        from {\n            transform: scale(0);\n            opacity: 0;\n        }\n        to {\n            transform: scale(1);\n            opacity: 1;\n        }\n    }\n\n    @keyframes showWithColor {\n        from {\n            background-color: var(${tokens.itemBackground});\n        }\n        to {\n            background-color: var(${tokens.activeItemBackground});\n        }\n    }\n\n    @keyframes hideWithColor {\n        from {\n            background-color: var(${tokens.activeItemBackground});\n        }\n        to {\n            background-color: var(${tokens.itemBackground});\n        }\n    }\n\n    @keyframes hideAnimation {\n        from {\n            transform: scale(1);\n            opacity: 1;\n        }\n        to {\n            transform: scale(0);\n            opacity: 0;\n        }\n    }\n\n    @keyframes reversedWidthAnimation {\n        from {\n            width: var(${tokens.lineWidth});\n            height: var(${tokens.lineHeight});\n            border-radius: var(${tokens.lineBorderRadius});\n            background-color: var(${tokens.activeItemBackground});\n        }\n        to {\n            width: var(--plasma-private-dot-size);\n            height: var(--plasma-private-dot-size);\n            border-radius: var(${tokens.lineBorderRadius});\n            background-color: var(${tokens.itemBackground});\n        }\n    }\n\n    @keyframes reversedHeightAnimation {\n        from {\n            width: var(${tokens.verticalLineWidth});\n            height: var(${tokens.verticalLineHeight});\n            border-radius: var(${tokens.lineBorderRadius});\n        }\n        to {\n            width: var(--plasma-private-dot-size);\n            height: var(--plasma-private-dot-size);\n            border-radius: var(${tokens.lineBorderRadius});\n        }\n    }\n\n    &.${classes.prevActive} {\n        &[data-view='line'] {\n            &:before {\n                animation-name: reversedWidthAnimation;\n                animation-duration: 0.3s;\n                animation-iteration-count: 1;\n                animation-play-state: running;\n                animation-timing-function: linear;\n            }\n\n            &.${classes.vertical} {\n                &:before {\n                    animation-name: reversedHeightAnimation;\n                }\n            }\n        }\n\n        &[data-view='dot'] {\n            &:before {\n                animation-name: hideWithColor;\n                animation-duration: 0.3s;\n                animation-iteration-count: 1;\n                animation-play-state: running;\n                animation-timing-function: linear;\n                animation-timing-function: ease-out;\n            }\n        }\n    }\n\n    &.hidden {\n        position: absolute;\n        animation-name: hideAnimation;\n        animation-duration: calc(0.3s + 0.1s);\n        animation-iteration-count: 1;\n        animation-play-state: running;\n        animation-timing-function: linear;\n    }\n\n    &.showed {\n        position: absolute;\n        animation-name: showAnimation;\n        animation-duration: 0.3s;\n        animation-iteration-count: 1;\n        animation-play-state: running;\n        animation-timing-function: linear;\n    }\n\n    &.${classes.active} {\n        &[data-view='dot'] {\n            &:before {\n                animation-name: showWithColor;\n                animation-duration: 0.3s;\n                animation-iteration-count: 1;\n                animation-play-state: running;\n                animation-timing-function: linear;\n                animation-timing-function: ease-in;\n            }\n        }\n    }\n\n    &.${classes.skipAnimation} {\n        transition: none;\n        animation-name: none !important;\n\n        &:before {\n            transition: none;\n            animation-name: none !important;\n        }\n    }\n`;\n\nexport const Line = styled(Dot)`\n    @keyframes widthAnimation {\n        from {\n            width: var(${tokens.lineHeight});\n            height: var(${tokens.lineHeight});\n            background-color: var(${tokens.itemBackground});\n        }\n        to {\n            width: var(${tokens.lineWidth});\n            height: var(${tokens.lineHeight});\n            background-color: var(${tokens.activeItemBackground});\n        }\n    }\n\n    @keyframes heightAnimation {\n        from {\n            width: var(${tokens.lineHeight});\n            height: var(${tokens.lineHeight});\n            background-color: var(${tokens.itemBackground});\n        }\n        to {\n            width: var(${tokens.verticalLineWidth});\n            height: var(${tokens.verticalLineHeight});\n            background-color: var(${tokens.activeItemBackground});\n        }\n    }\n\n    &[data-size='s'] {\n        &:before {\n            width: var(${tokens.lineWidth});\n            height: var(${tokens.lineHeight});\n            border-radius: var(${tokens.lineBorderRadius});\n        }\n    }\n\n    &[data-size='m'] {\n        &:before {\n            width: var(${tokens.lineWidth});\n            height: var(${tokens.lineHeight});\n            border-radius: var(${tokens.lineBorderRadius});\n        }\n    }\n\n    &.${classes.vertical} {\n        &[data-size='s'] {\n            &:before {\n                width: var(${tokens.verticalLineWidth});\n                height: var(${tokens.verticalLineHeight});\n            }\n        }\n\n        &[data-size='m'] {\n            &:before {\n                width: var(${tokens.verticalLineWidth});\n                height: var(${tokens.verticalLineHeight});\n            }\n        }\n    }\n\n    &.${classes.active} {\n        &:before {\n            animation-name: widthAnimation;\n            animation-duration: 0.3s;\n            animation-iteration-count: 1;\n            animation-play-state: running;\n            animation-timing-function: linear;\n        }\n\n        &.${classes.vertical} {\n            &:before {\n                animation-name: heightAnimation;\n            }\n        }\n    }\n\n    &.${classes.skipAnimation} {\n        animation-name: none !important;\n\n        &:before {\n            animation-name: none !important;\n        }\n    }\n`;\n\nexport const base = css`\n    display: flex;\n    align-items: center;\n    justify-content: flex-start;\n\n    &.${classes.centered} {\n        width: 100%;\n        justify-content: center;\n    }\n\n    &.${classes.vertical} {\n        display: inline-flex;\n        flex-direction: column;\n        align-items: center;\n\n        ${Dot} {\n            padding: var(${tokens.verticalDotPadding});\n        }\n\n        ${AnimatedDotsWrapper} {\n            flex-direction: column;\n        }\n\n        &.${classes.centered} {\n            width: auto;\n            height: 100%;\n\n            position: relative;\n        }\n    }\n`;\n"]} */",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+});
+export var Dot = /*#__PURE__*/_styled("div", {
+  target: "e95px8o1",
+  label: "plasma-new-hope__Dot"
+})("box-sizing:border-box;padding:var(", tokens.dotPadding, ");&:before{content:'';display:block;border-radius:var(", tokens.dotBorderRadius, ");background-color:var(", tokens.itemBackground, ");transition:width 0.3s linear,height 0.3s linear;}&.", classes.active, "{&:before{background-color:var(", tokens.activeItemBackground, ");}}&[data-size='xs']{&:before{--plasma-private-dot-size:var(", tokens.dotSizeXS, ");width:var(", tokens.dotSizeXS, ");height:var(", tokens.dotSizeXS, ");}}&[data-size='s']{&:before{--plasma-private-dot-size:var(", tokens.dotSizeS, ");width:var(", tokens.dotSizeS, ");height:var(", tokens.dotSizeS, ");}}&[data-size='m']{&:before{--plasma-private-dot-size:var(", tokens.dotSizeM, ");width:var(", tokens.dotSizeM, ");height:var(", tokens.dotSizeM, ");}}&.", classes.clickable, "{cursor:pointer;}@keyframes showAnimation{from{transform:scale(0);opacity:0;}to{transform:scale(1);opacity:1;}}@keyframes showWithColor{from{background-color:var(", tokens.itemBackground, ");}to{background-color:var(", tokens.activeItemBackground, ");}}@keyframes hideWithColor{from{background-color:var(", tokens.activeItemBackground, ");}to{background-color:var(", tokens.itemBackground, ");}}@keyframes hideAnimation{from{transform:scale(1);opacity:1;}to{transform:scale(0);opacity:0;}}@keyframes reversedWidthAnimation{from{width:var(", tokens.lineWidth, ");height:var(", tokens.lineHeight, ");border-radius:var(", tokens.lineBorderRadius, ");background-color:var(", tokens.activeItemBackground, ");}to{width:var(--plasma-private-dot-size);height:var(--plasma-private-dot-size);border-radius:var(", tokens.lineBorderRadius, ");background-color:var(", tokens.itemBackground, ");}}@keyframes reversedHeightAnimation{from{width:var(", tokens.verticalLineWidth, ");height:var(", tokens.verticalLineHeight, ");border-radius:var(", tokens.lineBorderRadius, ");}to{width:var(--plasma-private-dot-size);height:var(--plasma-private-dot-size);border-radius:var(", tokens.lineBorderRadius, ");}}&.", classes.prevActive, "{&[data-view='line']{&:before{animation-name:reversedWidthAnimation;animation-duration:0.3s;animation-iteration-count:1;animation-play-state:running;animation-timing-function:linear;}&.", classes.vertical, "{&:before{animation-name:reversedHeightAnimation;}}}&[data-view='dot']{&:before{animation-name:hideWithColor;animation-duration:0.3s;animation-iteration-count:1;animation-play-state:running;animation-timing-function:linear;animation-timing-function:ease-out;}}}&.hidden{position:absolute;animation-name:hideAnimation;animation-duration:calc(0.3s + 0.1s);animation-iteration-count:1;animation-play-state:running;animation-timing-function:linear;}&.showed{position:absolute;animation-name:showAnimation;animation-duration:0.3s;animation-iteration-count:1;animation-play-state:running;animation-timing-function:linear;}&.", classes.active, "{&[data-view='dot']{&:before{animation-name:showWithColor;animation-duration:0.3s;animation-iteration-count:1;animation-play-state:running;animation-timing-function:linear;animation-timing-function:ease-in;}}}&.", classes.skipAnimation, "{transition:none;animation-name:none!important;&:before{transition:none;animation-name:none!important;}}" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src-emotion/components/PaginationDots/PaginationDots.styles.ts"],"names":[],"mappings":"AAkB6B","file":"../../../../src-emotion/components/PaginationDots/PaginationDots.styles.ts","sourcesContent":["import { css } from '@emotion/react';\nimport styled from '@emotion/styled';\n\nimport { classes, tokens } from './PaginationDots.tokens';\n\nexport const Wrapper = styled.div`\n    position: relative;\n    display: flex;\n    align-items: center;\n    justify-content: center;\n`;\n\nexport const AnimatedDotsWrapper = styled.div`\n    display: flex;\n    align-items: center;\n    justify-content: center;\n`;\n\nexport const Dot = styled.div`\n    box-sizing: border-box;\n    padding: var(${tokens.dotPadding});\n\n    &:before {\n        content: '';\n        display: block;\n        border-radius: var(${tokens.dotBorderRadius});\n        background-color: var(${tokens.itemBackground});\n        transition: width 0.3s linear, height 0.3s linear;\n    }\n\n    &.${classes.active} {\n        &:before {\n            background-color: var(${tokens.activeItemBackground});\n        }\n    }\n\n    &[data-size='xs'] {\n        &:before {\n            --plasma-private-dot-size: var(${tokens.dotSizeXS});\n            width: var(${tokens.dotSizeXS});\n            height: var(${tokens.dotSizeXS});\n        }\n    }\n\n    &[data-size='s'] {\n        &:before {\n            --plasma-private-dot-size: var(${tokens.dotSizeS});\n            width: var(${tokens.dotSizeS});\n            height: var(${tokens.dotSizeS});\n        }\n    }\n\n    &[data-size='m'] {\n        &:before {\n            --plasma-private-dot-size: var(${tokens.dotSizeM});\n            width: var(${tokens.dotSizeM});\n            height: var(${tokens.dotSizeM});\n        }\n    }\n\n    &.${classes.clickable} {\n        cursor: pointer;\n    }\n\n    @keyframes showAnimation {\n        from {\n            transform: scale(0);\n            opacity: 0;\n        }\n        to {\n            transform: scale(1);\n            opacity: 1;\n        }\n    }\n\n    @keyframes showWithColor {\n        from {\n            background-color: var(${tokens.itemBackground});\n        }\n        to {\n            background-color: var(${tokens.activeItemBackground});\n        }\n    }\n\n    @keyframes hideWithColor {\n        from {\n            background-color: var(${tokens.activeItemBackground});\n        }\n        to {\n            background-color: var(${tokens.itemBackground});\n        }\n    }\n\n    @keyframes hideAnimation {\n        from {\n            transform: scale(1);\n            opacity: 1;\n        }\n        to {\n            transform: scale(0);\n            opacity: 0;\n        }\n    }\n\n    @keyframes reversedWidthAnimation {\n        from {\n            width: var(${tokens.lineWidth});\n            height: var(${tokens.lineHeight});\n            border-radius: var(${tokens.lineBorderRadius});\n            background-color: var(${tokens.activeItemBackground});\n        }\n        to {\n            width: var(--plasma-private-dot-size);\n            height: var(--plasma-private-dot-size);\n            border-radius: var(${tokens.lineBorderRadius});\n            background-color: var(${tokens.itemBackground});\n        }\n    }\n\n    @keyframes reversedHeightAnimation {\n        from {\n            width: var(${tokens.verticalLineWidth});\n            height: var(${tokens.verticalLineHeight});\n            border-radius: var(${tokens.lineBorderRadius});\n        }\n        to {\n            width: var(--plasma-private-dot-size);\n            height: var(--plasma-private-dot-size);\n            border-radius: var(${tokens.lineBorderRadius});\n        }\n    }\n\n    &.${classes.prevActive} {\n        &[data-view='line'] {\n            &:before {\n                animation-name: reversedWidthAnimation;\n                animation-duration: 0.3s;\n                animation-iteration-count: 1;\n                animation-play-state: running;\n                animation-timing-function: linear;\n            }\n\n            &.${classes.vertical} {\n                &:before {\n                    animation-name: reversedHeightAnimation;\n                }\n            }\n        }\n\n        &[data-view='dot'] {\n            &:before {\n                animation-name: hideWithColor;\n                animation-duration: 0.3s;\n                animation-iteration-count: 1;\n                animation-play-state: running;\n                animation-timing-function: linear;\n                animation-timing-function: ease-out;\n            }\n        }\n    }\n\n    &.hidden {\n        position: absolute;\n        animation-name: hideAnimation;\n        animation-duration: calc(0.3s + 0.1s);\n        animation-iteration-count: 1;\n        animation-play-state: running;\n        animation-timing-function: linear;\n    }\n\n    &.showed {\n        position: absolute;\n        animation-name: showAnimation;\n        animation-duration: 0.3s;\n        animation-iteration-count: 1;\n        animation-play-state: running;\n        animation-timing-function: linear;\n    }\n\n    &.${classes.active} {\n        &[data-view='dot'] {\n            &:before {\n                animation-name: showWithColor;\n                animation-duration: 0.3s;\n                animation-iteration-count: 1;\n                animation-play-state: running;\n                animation-timing-function: linear;\n                animation-timing-function: ease-in;\n            }\n        }\n    }\n\n    &.${classes.skipAnimation} {\n        transition: none;\n        animation-name: none !important;\n\n        &:before {\n            transition: none;\n            animation-name: none !important;\n        }\n    }\n`;\n\nexport const Line = styled(Dot)`\n    @keyframes widthAnimation {\n        from {\n            width: var(${tokens.lineHeight});\n            height: var(${tokens.lineHeight});\n            background-color: var(${tokens.itemBackground});\n        }\n        to {\n            width: var(${tokens.lineWidth});\n            height: var(${tokens.lineHeight});\n            background-color: var(${tokens.activeItemBackground});\n        }\n    }\n\n    @keyframes heightAnimation {\n        from {\n            width: var(${tokens.lineHeight});\n            height: var(${tokens.lineHeight});\n            background-color: var(${tokens.itemBackground});\n        }\n        to {\n            width: var(${tokens.verticalLineWidth});\n            height: var(${tokens.verticalLineHeight});\n            background-color: var(${tokens.activeItemBackground});\n        }\n    }\n\n    &[data-size='s'] {\n        &:before {\n            width: var(${tokens.lineWidth});\n            height: var(${tokens.lineHeight});\n            border-radius: var(${tokens.lineBorderRadius});\n        }\n    }\n\n    &[data-size='m'] {\n        &:before {\n            width: var(${tokens.lineWidth});\n            height: var(${tokens.lineHeight});\n            border-radius: var(${tokens.lineBorderRadius});\n        }\n    }\n\n    &.${classes.vertical} {\n        &[data-size='s'] {\n            &:before {\n                width: var(${tokens.verticalLineWidth});\n                height: var(${tokens.verticalLineHeight});\n            }\n        }\n\n        &[data-size='m'] {\n            &:before {\n                width: var(${tokens.verticalLineWidth});\n                height: var(${tokens.verticalLineHeight});\n            }\n        }\n    }\n\n    &.${classes.active} {\n        &:before {\n            animation-name: widthAnimation;\n            animation-duration: 0.3s;\n            animation-iteration-count: 1;\n            animation-play-state: running;\n            animation-timing-function: linear;\n        }\n\n        &.${classes.vertical} {\n            &:before {\n                animation-name: heightAnimation;\n            }\n        }\n    }\n\n    &.${classes.skipAnimation} {\n        animation-name: none !important;\n\n        &:before {\n            animation-name: none !important;\n        }\n    }\n`;\n\nexport const base = css`\n    display: flex;\n    align-items: center;\n    justify-content: flex-start;\n\n    &.${classes.centered} {\n        width: 100%;\n        justify-content: center;\n    }\n\n    &.${classes.vertical} {\n        display: inline-flex;\n        flex-direction: column;\n        align-items: center;\n\n        ${Dot} {\n            padding: var(${tokens.verticalDotPadding});\n        }\n\n        ${AnimatedDotsWrapper} {\n            flex-direction: column;\n        }\n\n        &.${classes.centered} {\n            width: auto;\n            height: 100%;\n\n            position: relative;\n        }\n    }\n`;\n"]} */"));
+export var Line = /*#__PURE__*/_styled(Dot, {
+  target: "e95px8o0",
+  label: "plasma-new-hope__Line"
+})("@keyframes widthAnimation{from{width:var(", tokens.lineHeight, ");height:var(", tokens.lineHeight, ");background-color:var(", tokens.itemBackground, ");}to{width:var(", tokens.lineWidth, ");height:var(", tokens.lineHeight, ");background-color:var(", tokens.activeItemBackground, ");}}@keyframes heightAnimation{from{width:var(", tokens.lineHeight, ");height:var(", tokens.lineHeight, ");background-color:var(", tokens.itemBackground, ");}to{width:var(", tokens.verticalLineWidth, ");height:var(", tokens.verticalLineHeight, ");background-color:var(", tokens.activeItemBackground, ");}}&[data-size='s']{&:before{width:var(", tokens.lineWidth, ");height:var(", tokens.lineHeight, ");border-radius:var(", tokens.lineBorderRadius, ");}}&[data-size='m']{&:before{width:var(", tokens.lineWidth, ");height:var(", tokens.lineHeight, ");border-radius:var(", tokens.lineBorderRadius, ");}}&.", classes.vertical, "{&[data-size='s']{&:before{width:var(", tokens.verticalLineWidth, ");height:var(", tokens.verticalLineHeight, ");}}&[data-size='m']{&:before{width:var(", tokens.verticalLineWidth, ");height:var(", tokens.verticalLineHeight, ");}}}&.", classes.active, "{&:before{animation-name:widthAnimation;animation-duration:0.3s;animation-iteration-count:1;animation-play-state:running;animation-timing-function:linear;}&.", classes.vertical, "{&:before{animation-name:heightAnimation;}}}&.", classes.skipAnimation, "{animation-name:none!important;&:before{animation-name:none!important;}}" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src-emotion/components/PaginationDots/PaginationDots.styles.ts"],"names":[],"mappings":"AA2M+B","file":"../../../../src-emotion/components/PaginationDots/PaginationDots.styles.ts","sourcesContent":["import { css } from '@emotion/react';\nimport styled from '@emotion/styled';\n\nimport { classes, tokens } from './PaginationDots.tokens';\n\nexport const Wrapper = styled.div`\n    position: relative;\n    display: flex;\n    align-items: center;\n    justify-content: center;\n`;\n\nexport const AnimatedDotsWrapper = styled.div`\n    display: flex;\n    align-items: center;\n    justify-content: center;\n`;\n\nexport const Dot = styled.div`\n    box-sizing: border-box;\n    padding: var(${tokens.dotPadding});\n\n    &:before {\n        content: '';\n        display: block;\n        border-radius: var(${tokens.dotBorderRadius});\n        background-color: var(${tokens.itemBackground});\n        transition: width 0.3s linear, height 0.3s linear;\n    }\n\n    &.${classes.active} {\n        &:before {\n            background-color: var(${tokens.activeItemBackground});\n        }\n    }\n\n    &[data-size='xs'] {\n        &:before {\n            --plasma-private-dot-size: var(${tokens.dotSizeXS});\n            width: var(${tokens.dotSizeXS});\n            height: var(${tokens.dotSizeXS});\n        }\n    }\n\n    &[data-size='s'] {\n        &:before {\n            --plasma-private-dot-size: var(${tokens.dotSizeS});\n            width: var(${tokens.dotSizeS});\n            height: var(${tokens.dotSizeS});\n        }\n    }\n\n    &[data-size='m'] {\n        &:before {\n            --plasma-private-dot-size: var(${tokens.dotSizeM});\n            width: var(${tokens.dotSizeM});\n            height: var(${tokens.dotSizeM});\n        }\n    }\n\n    &.${classes.clickable} {\n        cursor: pointer;\n    }\n\n    @keyframes showAnimation {\n        from {\n            transform: scale(0);\n            opacity: 0;\n        }\n        to {\n            transform: scale(1);\n            opacity: 1;\n        }\n    }\n\n    @keyframes showWithColor {\n        from {\n            background-color: var(${tokens.itemBackground});\n        }\n        to {\n            background-color: var(${tokens.activeItemBackground});\n        }\n    }\n\n    @keyframes hideWithColor {\n        from {\n            background-color: var(${tokens.activeItemBackground});\n        }\n        to {\n            background-color: var(${tokens.itemBackground});\n        }\n    }\n\n    @keyframes hideAnimation {\n        from {\n            transform: scale(1);\n            opacity: 1;\n        }\n        to {\n            transform: scale(0);\n            opacity: 0;\n        }\n    }\n\n    @keyframes reversedWidthAnimation {\n        from {\n            width: var(${tokens.lineWidth});\n            height: var(${tokens.lineHeight});\n            border-radius: var(${tokens.lineBorderRadius});\n            background-color: var(${tokens.activeItemBackground});\n        }\n        to {\n            width: var(--plasma-private-dot-size);\n            height: var(--plasma-private-dot-size);\n            border-radius: var(${tokens.lineBorderRadius});\n            background-color: var(${tokens.itemBackground});\n        }\n    }\n\n    @keyframes reversedHeightAnimation {\n        from {\n            width: var(${tokens.verticalLineWidth});\n            height: var(${tokens.verticalLineHeight});\n            border-radius: var(${tokens.lineBorderRadius});\n        }\n        to {\n            width: var(--plasma-private-dot-size);\n            height: var(--plasma-private-dot-size);\n            border-radius: var(${tokens.lineBorderRadius});\n        }\n    }\n\n    &.${classes.prevActive} {\n        &[data-view='line'] {\n            &:before {\n                animation-name: reversedWidthAnimation;\n                animation-duration: 0.3s;\n                animation-iteration-count: 1;\n                animation-play-state: running;\n                animation-timing-function: linear;\n            }\n\n            &.${classes.vertical} {\n                &:before {\n                    animation-name: reversedHeightAnimation;\n                }\n            }\n        }\n\n        &[data-view='dot'] {\n            &:before {\n                animation-name: hideWithColor;\n                animation-duration: 0.3s;\n                animation-iteration-count: 1;\n                animation-play-state: running;\n                animation-timing-function: linear;\n                animation-timing-function: ease-out;\n            }\n        }\n    }\n\n    &.hidden {\n        position: absolute;\n        animation-name: hideAnimation;\n        animation-duration: calc(0.3s + 0.1s);\n        animation-iteration-count: 1;\n        animation-play-state: running;\n        animation-timing-function: linear;\n    }\n\n    &.showed {\n        position: absolute;\n        animation-name: showAnimation;\n        animation-duration: 0.3s;\n        animation-iteration-count: 1;\n        animation-play-state: running;\n        animation-timing-function: linear;\n    }\n\n    &.${classes.active} {\n        &[data-view='dot'] {\n            &:before {\n                animation-name: showWithColor;\n                animation-duration: 0.3s;\n                animation-iteration-count: 1;\n                animation-play-state: running;\n                animation-timing-function: linear;\n                animation-timing-function: ease-in;\n            }\n        }\n    }\n\n    &.${classes.skipAnimation} {\n        transition: none;\n        animation-name: none !important;\n\n        &:before {\n            transition: none;\n            animation-name: none !important;\n        }\n    }\n`;\n\nexport const Line = styled(Dot)`\n    @keyframes widthAnimation {\n        from {\n            width: var(${tokens.lineHeight});\n            height: var(${tokens.lineHeight});\n            background-color: var(${tokens.itemBackground});\n        }\n        to {\n            width: var(${tokens.lineWidth});\n            height: var(${tokens.lineHeight});\n            background-color: var(${tokens.activeItemBackground});\n        }\n    }\n\n    @keyframes heightAnimation {\n        from {\n            width: var(${tokens.lineHeight});\n            height: var(${tokens.lineHeight});\n            background-color: var(${tokens.itemBackground});\n        }\n        to {\n            width: var(${tokens.verticalLineWidth});\n            height: var(${tokens.verticalLineHeight});\n            background-color: var(${tokens.activeItemBackground});\n        }\n    }\n\n    &[data-size='s'] {\n        &:before {\n            width: var(${tokens.lineWidth});\n            height: var(${tokens.lineHeight});\n            border-radius: var(${tokens.lineBorderRadius});\n        }\n    }\n\n    &[data-size='m'] {\n        &:before {\n            width: var(${tokens.lineWidth});\n            height: var(${tokens.lineHeight});\n            border-radius: var(${tokens.lineBorderRadius});\n        }\n    }\n\n    &.${classes.vertical} {\n        &[data-size='s'] {\n            &:before {\n                width: var(${tokens.verticalLineWidth});\n                height: var(${tokens.verticalLineHeight});\n            }\n        }\n\n        &[data-size='m'] {\n            &:before {\n                width: var(${tokens.verticalLineWidth});\n                height: var(${tokens.verticalLineHeight});\n            }\n        }\n    }\n\n    &.${classes.active} {\n        &:before {\n            animation-name: widthAnimation;\n            animation-duration: 0.3s;\n            animation-iteration-count: 1;\n            animation-play-state: running;\n            animation-timing-function: linear;\n        }\n\n        &.${classes.vertical} {\n            &:before {\n                animation-name: heightAnimation;\n            }\n        }\n    }\n\n    &.${classes.skipAnimation} {\n        animation-name: none !important;\n\n        &:before {\n            animation-name: none !important;\n        }\n    }\n`;\n\nexport const base = css`\n    display: flex;\n    align-items: center;\n    justify-content: flex-start;\n\n    &.${classes.centered} {\n        width: 100%;\n        justify-content: center;\n    }\n\n    &.${classes.vertical} {\n        display: inline-flex;\n        flex-direction: column;\n        align-items: center;\n\n        ${Dot} {\n            padding: var(${tokens.verticalDotPadding});\n        }\n\n        ${AnimatedDotsWrapper} {\n            flex-direction: column;\n        }\n\n        &.${classes.centered} {\n            width: auto;\n            height: 100%;\n\n            position: relative;\n        }\n    }\n`;\n"]} */"));
+export var base = /*#__PURE__*/css("display:flex;align-items:center;justify-content:flex-start;&.", classes.centered, "{width:100%;justify-content:center;}&.", classes.vertical, "{display:inline-flex;flex-direction:column;align-items:center;", Dot, "{padding:var(", tokens.verticalDotPadding, ");}", AnimatedDotsWrapper, "{flex-direction:column;}&.", classes.centered, "{width:auto;height:100%;position:relative;}};label:plasma-new-hope__base;" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src-emotion/components/PaginationDots/PaginationDots.styles.ts"],"names":[],"mappings":"AA+RuB","file":"../../../../src-emotion/components/PaginationDots/PaginationDots.styles.ts","sourcesContent":["import { css } from '@emotion/react';\nimport styled from '@emotion/styled';\n\nimport { classes, tokens } from './PaginationDots.tokens';\n\nexport const Wrapper = styled.div`\n    position: relative;\n    display: flex;\n    align-items: center;\n    justify-content: center;\n`;\n\nexport const AnimatedDotsWrapper = styled.div`\n    display: flex;\n    align-items: center;\n    justify-content: center;\n`;\n\nexport const Dot = styled.div`\n    box-sizing: border-box;\n    padding: var(${tokens.dotPadding});\n\n    &:before {\n        content: '';\n        display: block;\n        border-radius: var(${tokens.dotBorderRadius});\n        background-color: var(${tokens.itemBackground});\n        transition: width 0.3s linear, height 0.3s linear;\n    }\n\n    &.${classes.active} {\n        &:before {\n            background-color: var(${tokens.activeItemBackground});\n        }\n    }\n\n    &[data-size='xs'] {\n        &:before {\n            --plasma-private-dot-size: var(${tokens.dotSizeXS});\n            width: var(${tokens.dotSizeXS});\n            height: var(${tokens.dotSizeXS});\n        }\n    }\n\n    &[data-size='s'] {\n        &:before {\n            --plasma-private-dot-size: var(${tokens.dotSizeS});\n            width: var(${tokens.dotSizeS});\n            height: var(${tokens.dotSizeS});\n        }\n    }\n\n    &[data-size='m'] {\n        &:before {\n            --plasma-private-dot-size: var(${tokens.dotSizeM});\n            width: var(${tokens.dotSizeM});\n            height: var(${tokens.dotSizeM});\n        }\n    }\n\n    &.${classes.clickable} {\n        cursor: pointer;\n    }\n\n    @keyframes showAnimation {\n        from {\n            transform: scale(0);\n            opacity: 0;\n        }\n        to {\n            transform: scale(1);\n            opacity: 1;\n        }\n    }\n\n    @keyframes showWithColor {\n        from {\n            background-color: var(${tokens.itemBackground});\n        }\n        to {\n            background-color: var(${tokens.activeItemBackground});\n        }\n    }\n\n    @keyframes hideWithColor {\n        from {\n            background-color: var(${tokens.activeItemBackground});\n        }\n        to {\n            background-color: var(${tokens.itemBackground});\n        }\n    }\n\n    @keyframes hideAnimation {\n        from {\n            transform: scale(1);\n            opacity: 1;\n        }\n        to {\n            transform: scale(0);\n            opacity: 0;\n        }\n    }\n\n    @keyframes reversedWidthAnimation {\n        from {\n            width: var(${tokens.lineWidth});\n            height: var(${tokens.lineHeight});\n            border-radius: var(${tokens.lineBorderRadius});\n            background-color: var(${tokens.activeItemBackground});\n        }\n        to {\n            width: var(--plasma-private-dot-size);\n            height: var(--plasma-private-dot-size);\n            border-radius: var(${tokens.lineBorderRadius});\n            background-color: var(${tokens.itemBackground});\n        }\n    }\n\n    @keyframes reversedHeightAnimation {\n        from {\n            width: var(${tokens.verticalLineWidth});\n            height: var(${tokens.verticalLineHeight});\n            border-radius: var(${tokens.lineBorderRadius});\n        }\n        to {\n            width: var(--plasma-private-dot-size);\n            height: var(--plasma-private-dot-size);\n            border-radius: var(${tokens.lineBorderRadius});\n        }\n    }\n\n    &.${classes.prevActive} {\n        &[data-view='line'] {\n            &:before {\n                animation-name: reversedWidthAnimation;\n                animation-duration: 0.3s;\n                animation-iteration-count: 1;\n                animation-play-state: running;\n                animation-timing-function: linear;\n            }\n\n            &.${classes.vertical} {\n                &:before {\n                    animation-name: reversedHeightAnimation;\n                }\n            }\n        }\n\n        &[data-view='dot'] {\n            &:before {\n                animation-name: hideWithColor;\n                animation-duration: 0.3s;\n                animation-iteration-count: 1;\n                animation-play-state: running;\n                animation-timing-function: linear;\n                animation-timing-function: ease-out;\n            }\n        }\n    }\n\n    &.hidden {\n        position: absolute;\n        animation-name: hideAnimation;\n        animation-duration: calc(0.3s + 0.1s);\n        animation-iteration-count: 1;\n        animation-play-state: running;\n        animation-timing-function: linear;\n    }\n\n    &.showed {\n        position: absolute;\n        animation-name: showAnimation;\n        animation-duration: 0.3s;\n        animation-iteration-count: 1;\n        animation-play-state: running;\n        animation-timing-function: linear;\n    }\n\n    &.${classes.active} {\n        &[data-view='dot'] {\n            &:before {\n                animation-name: showWithColor;\n                animation-duration: 0.3s;\n                animation-iteration-count: 1;\n                animation-play-state: running;\n                animation-timing-function: linear;\n                animation-timing-function: ease-in;\n            }\n        }\n    }\n\n    &.${classes.skipAnimation} {\n        transition: none;\n        animation-name: none !important;\n\n        &:before {\n            transition: none;\n            animation-name: none !important;\n        }\n    }\n`;\n\nexport const Line = styled(Dot)`\n    @keyframes widthAnimation {\n        from {\n            width: var(${tokens.lineHeight});\n            height: var(${tokens.lineHeight});\n            background-color: var(${tokens.itemBackground});\n        }\n        to {\n            width: var(${tokens.lineWidth});\n            height: var(${tokens.lineHeight});\n            background-color: var(${tokens.activeItemBackground});\n        }\n    }\n\n    @keyframes heightAnimation {\n        from {\n            width: var(${tokens.lineHeight});\n            height: var(${tokens.lineHeight});\n            background-color: var(${tokens.itemBackground});\n        }\n        to {\n            width: var(${tokens.verticalLineWidth});\n            height: var(${tokens.verticalLineHeight});\n            background-color: var(${tokens.activeItemBackground});\n        }\n    }\n\n    &[data-size='s'] {\n        &:before {\n            width: var(${tokens.lineWidth});\n            height: var(${tokens.lineHeight});\n            border-radius: var(${tokens.lineBorderRadius});\n        }\n    }\n\n    &[data-size='m'] {\n        &:before {\n            width: var(${tokens.lineWidth});\n            height: var(${tokens.lineHeight});\n            border-radius: var(${tokens.lineBorderRadius});\n        }\n    }\n\n    &.${classes.vertical} {\n        &[data-size='s'] {\n            &:before {\n                width: var(${tokens.verticalLineWidth});\n                height: var(${tokens.verticalLineHeight});\n            }\n        }\n\n        &[data-size='m'] {\n            &:before {\n                width: var(${tokens.verticalLineWidth});\n                height: var(${tokens.verticalLineHeight});\n            }\n        }\n    }\n\n    &.${classes.active} {\n        &:before {\n            animation-name: widthAnimation;\n            animation-duration: 0.3s;\n            animation-iteration-count: 1;\n            animation-play-state: running;\n            animation-timing-function: linear;\n        }\n\n        &.${classes.vertical} {\n            &:before {\n                animation-name: heightAnimation;\n            }\n        }\n    }\n\n    &.${classes.skipAnimation} {\n        animation-name: none !important;\n\n        &:before {\n            animation-name: none !important;\n        }\n    }\n`;\n\nexport const base = css`\n    display: flex;\n    align-items: center;\n    justify-content: flex-start;\n\n    &.${classes.centered} {\n        width: 100%;\n        justify-content: center;\n    }\n\n    &.${classes.vertical} {\n        display: inline-flex;\n        flex-direction: column;\n        align-items: center;\n\n        ${Dot} {\n            padding: var(${tokens.verticalDotPadding});\n        }\n\n        ${AnimatedDotsWrapper} {\n            flex-direction: column;\n        }\n\n        &.${classes.centered} {\n            width: auto;\n            height: 100%;\n\n            position: relative;\n        }\n    }\n`;\n"]} */"));

package/emotion/es/components/PaginationDots/PaginationDots.template-doc.mdx

@@ -0,0 +1,95 @@
+---
+id: segment
+title: Segment
+---
+
+import { PropsTable, Description } from '@site/src/components';
+
+# PaginationDots
+Элементы переключения. Oтображают возможность перемещения между небольшим количеством однородных элементов контента.
+
+## PaginationDots
+
+<Description name="PaginationDots" />
+<PropsTable name="PaginationDots"  exclude={['css']} />
+
+```tsx live
+import React from 'react';
+import { SegmentGroup, SegmentItem, SegmentProvider, useSegment } from '@salutejs/{{ package }}';
+
+export function App() {
+    const items = Array(8).fill(0);
+
+    const SegmentTemplate = () => {
+        const {selectedSegmentItems} = useSegment();
+
+        return (
+            <>
+                <div>Выбранный элемент: {selectedSegmentItems.join(', ')}</div>
+                <br />
+                <SegmentGroup hasBackground pilled clip={false}>
+                    {items.map((_, i) => (
+                        <SegmentItem
+                            label={`Label ${i}`}
+                            value={`label_${i}`}
+                            key={`label_${i}`}
+                            view='default'
+                            pilled
+                        />
+                    ))}
+                </SegmentGroup>
+            </>
+        )
+    }
+
+    return (
+        <div style={{ display: "block" }} >
+            <SegmentProvider defaultSelected={['label_1']}>
+                <SegmentTemplate/>
+            </SegmentProvider>
+        </div>
+    );
+}
+```
+
+### Вертикальное отображение
+
+Для смены ориентации передаем `orientation: 'vertical'`
+
+```tsx live
+import React from 'react';
+import { SegmentGroup, SegmentItem, SegmentProvider, useSegment } from '@salutejs/{{ package }}';
+
+export function App() {
+    const items = Array(8).fill(0);
+
+    const SegmentTemplate = () => {
+        const {selectedSegmentItems} = useSegment();
+
+        return (
+            <>
+                <div>Выбранный элемент: {selectedSegmentItems.join(', ')}</div>
+                <br />
+                <SegmentGroup hasBackground clip={false}>
+                    {items.map((_, i) => (
+                        <SegmentItem
+                            label={`Label ${i}`}
+                            value={`label_${i}`}
+                            key={`label_${i}`}
+                            view='secondary'
+                        />
+                    ))}
+                </SegmentGroup>
+            </>
+        )
+    }
+
+    return (
+        <div style={{ display: "block" }} >
+            <SegmentProvider defaultSelected={['label_1']}>
+                <SegmentTemplate/>
+            </SegmentProvider>
+        </div>
+    );
+}
+```

package/emotion/es/components/PaginationDots/PaginationDots.tokens.js

@@ -0,0 +1,24 @@
+export var classes = {
+  active: 'active',
+  prevActive: 'prevActive',
+  centered: 'centered',
+  vertical: 'vertical',
+  clickable: 'clickable',
+  skipAnimation: 'skipAnimation'
+};
+export var tokens = {
+  paginationWidth: '--plasma-pagination-width',
+  dotPadding: '--plasma-pagination-dots-dot-padding',
+  verticalDotPadding: '--plasma-pagination-dots-vertical-dot-padding',
+  dotSizeM: '--plasma-pagination-dots-dot-size-m',
+  dotSizeS: '--plasma-pagination-dots-dot-size-s',
+  dotSizeXS: '--plasma-pagination-dots-dot-size-xs',
+  dotBorderRadius: '--plasma-pagination-dots-dot-border-radius',
+  lineWidth: '--plasma-pagination-dots-line-width',
+  lineHeight: '--plasma-pagination-dots-line-height',
+  lineBorderRadius: '--plasma-pagination-dots-line-border-radius',
+  verticalLineWidth: '--plasma-pagination-dots-vertical-line-width',
+  verticalLineHeight: '--plasma-pagination-dots-vertical-line-height',
+  itemBackground: '--plasma-pagination-dots-item-background',
+  activeItemBackground: '--plasma-pagination-dots-active-item-background'
+};

package/emotion/es/components/PaginationDots/PaginationDots.types.js

@@ -0,0 +1 @@
+export {};