@onepercentio/one-ui 1.3.2 → 1.3.4

package/dist/components/OrderableList/OrderableList.module.scss

@@ -0,0 +1,98 @@
+$baseSpeed: 300ms;
+$fast: var(--orderable-list--speed);
+
+.unselectable * {
+  -webkit-touch-callout: none;
+  -webkit-user-select: none;
+  -khtml-user-select: none;
+  -moz-user-select: none;
+  -ms-user-select: none;
+  user-select: none;
+}
+
+.clone {
+  --orderable-list--speed: #{$baseSpeed};
+  transition: max-height $fast linear;
+  pointer-events: none;
+  position: fixed;
+  overflow: hidden;
+}
+
+.ordering {
+  > * {
+    opacity: 0;
+  }
+  .visible {
+    opacity: 1;
+    * {
+      pointer-events: none;
+    }
+  }
+}
+
+.shrinkable.ordering section.visible,
+.shrinkable.ordering section.currentOrdering {
+  max-height: var(--shrink-to) !important;
+}
+.shrinkable.ordering > section:not(.visible):not(.currentOrdering) > * {
+  max-height: var(--shrink-to) !important;
+}
+.transitionHeight {
+  transition: max-height $fast linear;
+}
+
+.root {
+  position: relative;
+  --orderable-list--speed: #{$baseSpeed};
+  transition: padding-top $fast linear;
+  > * {
+    transition: max-height $fast linear;
+    overflow: hidden;
+    > * > * {
+      flex-shrink: 0;
+    }
+  }
+
+  &::before {
+    position: absolute;
+    height: 100%;
+    width: 100%;
+    content: " ";
+  }
+}
+
+.transition {
+  width: 100%;
+  align-items: flex-start !important;
+  overflow: visible !important;
+  > * {
+    flex-direction: row !important;
+    flex-wrap: wrap;
+    // &:first-child {
+    //   visibility: hidden;
+    // }
+    &:last-child {
+      visibility: visible;
+    }
+  }
+}
+
+div.stub {
+  animation-name: stub;
+  position: absolute;
+  pointer-events: none;
+  opacity: 0 !important;
+}
+
+div.stubEntering {
+  animation-name: stub;
+  z-index: -1;
+}
+@keyframes stub {
+  0% {
+    opacity: 1;
+  }
+  100% {
+    opacity: 1;
+  }
+}

package/dist/components/OrderableList/index.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {};
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function () {
+    return _OrderableList.default;
+  }
+});
+var _OrderableList = _interopRequireWildcard(require("./OrderableList"));
+Object.keys(_OrderableList).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _OrderableList[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _OrderableList[key];
+    }
+  });
+});
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/components/PaginationIndicator/PaginationIndicator.js

@@ -0,0 +1,261 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AnimatedPaginationIndicator = AnimatedPaginationIndicator;
+exports.PaginationIndicatorMode = void 0;
+exports.PaginationIndicatorView = PaginationIndicatorView;
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+const MAX_BALLS = 7;
+const eachBallWidthEm = 1.2;
+const CENTER_GUIDE_BALL = 1;
+let PaginationIndicatorMode = exports.PaginationIndicatorMode = /*#__PURE__*/function (PaginationIndicatorMode) {
+  PaginationIndicatorMode[PaginationIndicatorMode["CENTERED"] = 0] = "CENTERED";
+  PaginationIndicatorMode[PaginationIndicatorMode["START"] = 1] = "START";
+  return PaginationIndicatorMode;
+}({});
+function PaginationIndicatorView(_ref) {
+  let {
+    size,
+    page: currentPage,
+    pages: decimalPages,
+    className,
+    onClickPage,
+    mode = PaginationIndicatorMode.CENTERED,
+    infinite
+  } = _ref;
+  const maxBalls = (0, _react.useMemo)(() => infinite ? 5 : MAX_BALLS, [infinite]);
+  const page = (0, _react.useMemo)(() => {
+    const floor = Math.floor(decimalPages);
+    const modulus = decimalPages % floor;
+    if (currentPage > floor) {
+      const currentFloorModulus = currentPage % floor;
+      const equivalent = currentFloorModulus * 100 / modulus;
+      return floor + equivalent / 100;
+    } else {
+      return currentPage;
+    }
+  }, [currentPage, decimalPages]);
+  const rand = (0, _react.useMemo)(() => Math.random().toString(), []);
+  const pageIndex = page - 1;
+  const pages = (0, _react.useMemo)(() => Math.ceil(decimalPages), [decimalPages]);
+  const numBalls = (0, _react.useMemo)(() => {
+    const numBalls = pages >= maxBalls ? maxBalls : Math.ceil(pages);
+    return numBalls;
+  }, [pages]);
+  const indexForTheBallsCenter = (0, _react.useMemo)(() => (infinite ? numBalls - 5 : numBalls - 1) / 2, [numBalls, infinite]);
+  const balls = (0, _react.useMemo)(() => {
+    const indexForLastPages = pages + 1 - indexForTheBallsCenter;
+    /**
+     * Is the page index (position of the center)
+     * after the first pages and
+     * before the last pages */
+    const isCenterPage = numBalls >= maxBalls && pageIndex > indexForTheBallsCenter && pageIndex < indexForLastPages - 1;
+    let modulus = pageIndex % (1 + (indexForTheBallsCenter - Math.floor(indexForTheBallsCenter)));
+    const resetPageIndex = isCenterPage ? indexForTheBallsCenter + modulus : pages < maxBalls ? pageIndex : pageIndex >= indexForLastPages - 1 ? numBalls - (pages - pageIndex) : pageIndex;
+    const left = eachBallWidthEm * resetPageIndex;
+    const {
+      pushBallsToRightBy,
+      pushBallsToLeftBy,
+      pushGuideToRightBy
+    } = mode === PaginationIndicatorMode.CENTERED ? {
+      pushBallsToRightBy: Math.min(pages, maxBalls) * eachBallWidthEm,
+      pushBallsToLeftBy: left,
+      pushGuideToRightBy: 0
+    } : {
+      pushBallsToRightBy: (eachBallWidthEm - 0.5) / 2,
+      pushBallsToLeftBy: 0,
+      pushGuideToRightBy: left
+    };
+    let pushToLeft = 0;
+    return new Array(CENTER_GUIDE_BALL + numBalls).fill(undefined).map((_, i) => {
+      const isLastBall = i === numBalls - 1;
+      const isFirstBall = i === 0;
+      if (i === numBalls) {
+        const diameter = 0.45 * 2;
+        const padding = (eachBallWidthEm - diameter) / 2;
+        return /*#__PURE__*/_react.default.createElement("rect", {
+          fill: "#fff",
+          width: "".concat(diameter, "em"),
+          height: "".concat(diameter, "em"),
+          x: "".concat(pushBallsToRightBy - padding + pushGuideToRightBy - pushToLeft, "em"),
+          y: "".concat(padding, "em"),
+          rx: "".concat(diameter / 2, "em")
+        });
+      }
+      const ballSize = numBalls < maxBalls ? 0.5 : page <= indexForTheBallsCenter + 1 && isLastBall ? 0 : pageIndex >= indexForLastPages - 1 && isFirstBall ? 0 : isCenterPage ? isFirstBall ? 0.5 - modulus * 0.5 : isLastBall ? modulus * 0.5 : 0.5 : 0.5;
+      if (i === 0 && mode === PaginationIndicatorMode.START) pushToLeft = (0.5 - ballSize) * 2.4;
+      return /*#__PURE__*/_react.default.createElement("rect", {
+        key: "guide-".concat(i),
+        width: "".concat(ballSize * 1.2, "em"),
+        height: "".concat(ballSize * 1.2, "em"),
+        x: "".concat(pushBallsToRightBy + i * eachBallWidthEm - pushBallsToLeftBy - pushToLeft, "em"),
+        y: "".concat((eachBallWidthEm - ballSize * 1.2) / 2, "em"),
+        rx: "".concat(ballSize * 1.2 / 2, "em"),
+        onClick: () => {
+          if (onClickPage) {
+            const pageClicked = (!isCenterPage ? pageIndex >= indexForLastPages - 1 ? Math.floor(page) - resetPageIndex - 1 : 0 : Math.floor(page) - (indexForTheBallsCenter + 1)) + 1 + i;
+            onClickPage(Math.round(pageClicked));
+          }
+        }
+      });
+    });
+  }, [indexForTheBallsCenter, pageIndex, pages]);
+  const [guideBall, ...pageBalls] = balls.reverse();
+  let width = eachBallWidthEm * Math.min(pages, maxBalls) * 2;
+  if (mode === PaginationIndicatorMode.START) width /= 2;
+  return /*#__PURE__*/_react.default.createElement("svg", {
+    version: "1.1",
+    xmlns: "http://www.w3.org/2000/svg",
+    className: className,
+    style: {
+      width: "".concat(width, "em"),
+      minWidth: "".concat(width, "em"),
+      height: "1.2em",
+      fontSize: "".concat(size, "px")
+    }
+  }, /*#__PURE__*/_react.default.createElement("filter", {
+    id: "goo-".concat(rand)
+  }, /*#__PURE__*/_react.default.createElement("feGaussianBlur", {
+    in: "SourceGraphic",
+    result: "blur",
+    stdDeviation: "5"
+  }), /*#__PURE__*/_react.default.createElement("feColorMatrix", {
+    in: "blur",
+    mode: "matrix",
+    values: "1 0 0 0 0  0 1 0 0 0  0 0 1 0 0  0 0 0 18 -7",
+    result: "goo"
+  }), /*#__PURE__*/_react.default.createElement("feBlend", {
+    in2: "goo",
+    in: "SourceGraphic",
+    result: "mix"
+  })), /*#__PURE__*/_react.default.createElement("mask", {
+    id: "mask-".concat(rand)
+  }, /*#__PURE__*/_react.default.createElement("g", {
+    filter: "url(#".concat("goo-".concat(rand), ")"),
+    fill: "#fff"
+  }, [pageBalls], guideBall)), /*#__PURE__*/_react.default.createElement("rect", {
+    x: "0",
+    y: "0",
+    mask: "url(#".concat("mask-".concat(rand), ")"),
+    width: "100%",
+    height: "100%",
+    style: {
+      fill: "var(--digital-blue)"
+    }
+  }), onClickPage && /*#__PURE__*/_react.default.createElement("g", {
+    opacity: 0,
+    style: {
+      cursor: "pointer"
+    }
+  }, pageBalls));
+}
+function AnimatedPaginationIndicator(props) {
+  const prevPage = (0, _react.useRef)(props.page);
+  const [pageProgress, setPageProgress] = (0, _react.useState)(props.page);
+  (0, _react.useEffect)(() => {
+    const diff = props.page - prevPage.current;
+    const diffPerStep = diff / 60;
+    const interval = setInterval(() => {
+      setPageProgress(prev => {
+        const next = prev + diffPerStep;
+        if (diff < 0) {
+          if (next <= props.page) {
+            clearInterval(interval);
+            return props.page;
+          }
+        } else {
+          if (next >= props.page) {
+            clearInterval(interval);
+            return props.page;
+          }
+        }
+        return Number(next.toFixed(2));
+      });
+    }, props.duration / 60);
+    return () => {
+      prevPage.current = props.page;
+      clearInterval(interval);
+    };
+  }, [props.page]);
+  return /*#__PURE__*/_react.default.createElement(PaginationIndicatorView, _extends({}, props, {
+    page: pageProgress
+  }));
+}
+function _PaginationIndicator(_ref2, ref) {
+  let {
+    scrollableRef,
+    estimatedWidth,
+    size,
+    className = "",
+    onClickPage,
+    mode,
+    infinite
+  } = _ref2;
+  const [currentPage, setCurrentPage] = (0, _react.useState)(1);
+  const [defs, setDefs] = (0, _react.useState)();
+  const refreshPages = (0, _react.useCallback)(() => {
+    if (!scrollableRef.current) return;
+    const maxWidth = estimatedWidth === undefined ? scrollableRef.current.scrollWidth : estimatedWidth;
+    const pages = maxWidth / scrollableRef.current.clientWidth;
+    if (pages > 1) setDefs({
+      pages: infinite ? pages + 2 : pages
+    });
+  }, [estimatedWidth, infinite]);
+  (0, _react.useEffect)(() => refreshPages(), [refreshPages]);
+  const updatePageIndicators = (0, _react.useCallback)((target, pages) => {
+    if (!scrollableRef.current) return;
+    const eachPageWidth = scrollableRef.current.clientWidth;
+    const page = 1 + target.scrollLeft / eachPageWidth;
+    const lastPageProgress = Math.floor(pages) + 1;
+    const maximumProgress = pages + 1;
+    const diffToMax = maximumProgress - lastPageProgress;
+    const currentProgressOnDiff = page - lastPageProgress;
+    if (page > lastPageProgress) {
+      const p = lastPageProgress + currentProgressOnDiff / diffToMax;
+      setCurrentPage(p);
+    } else setCurrentPage(page);
+  }, []);
+  (0, _react.useImperativeHandle)(ref, () => ({
+    refreshPages
+  }), []);
+  (0, _react.useEffect)(() => {
+    if (!defs) return;
+    const el = scrollableRef.current;
+    const onScroll = e => updatePageIndicators(e.currentTarget, defs.pages);
+    updatePageIndicators(el, defs.pages);
+    el.addEventListener("scroll", onScroll, {
+      passive: true
+    });
+    return () => {
+      el.removeEventListener("scroll", onScroll);
+    };
+  }, [defs]);
+  const pages = (0, _react.useMemo)(() => defs ? defs.pages : undefined, [defs]);
+  return !pages ? null : /*#__PURE__*/_react.default.createElement(PaginationIndicatorView, {
+    pages: pages,
+    page: currentPage,
+    size: size,
+    className: className,
+    onClickPage: onClickPage,
+    mode: mode,
+    infinite: infinite
+  });
+}
+
+/**
+ * A cool component to indicate how many pages are
+ **/
+/**
+ * A pagination indicator component that displays the current page
+ * and total number of pages using animated circular indicators.
+ * It updates visually when scrolling through pages.
+ */
+const PaginationIndicator = /*#__PURE__*/(0, _react.forwardRef)(_PaginationIndicator);
+var _default = exports.default = PaginationIndicator;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireWildcard","require","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","_extends","assign","bind","target","i","arguments","length","source","apply","MAX_BALLS","eachBallWidthEm","CENTER_GUIDE_BALL","PaginationIndicatorMode","exports","PaginationIndicatorView","_ref","size","page","currentPage","pages","decimalPages","className","onClickPage","mode","CENTERED","infinite","maxBalls","useMemo","floor","Math","modulus","currentFloorModulus","equivalent","rand","random","toString","pageIndex","ceil","numBalls","indexForTheBallsCenter","balls","indexForLastPages","isCenterPage","resetPageIndex","left","pushBallsToRightBy","pushBallsToLeftBy","pushGuideToRightBy","min","pushToLeft","Array","fill","undefined","map","_","isLastBall","isFirstBall","diameter","padding","createElement","width","concat","height","x","y","rx","ballSize","START","onClick","pageClicked","round","guideBall","pageBalls","reverse","version","xmlns","style","minWidth","fontSize","id","in","result","stdDeviation","values","in2","filter","mask","opacity","cursor","AnimatedPaginationIndicator","props","prevPage","useRef","pageProgress","setPageProgress","useState","useEffect","diff","current","diffPerStep","interval","setInterval","prev","next","clearInterval","Number","toFixed","duration","_PaginationIndicator","_ref2","ref","scrollableRef","estimatedWidth","setCurrentPage","defs","setDefs","refreshPages","useCallback","maxWidth","scrollWidth","clientWidth","updatePageIndicators","eachPageWidth","scrollLeft","lastPageProgress","maximumProgress","diffToMax","currentProgressOnDiff","p","useImperativeHandle","el","onScroll","e","currentTarget","addEventListener","passive","removeEventListener","PaginationIndicator","forwardRef","_default"],"sources":["../../../src/components/PaginationIndicator/PaginationIndicator.tsx"],"sourcesContent":["import React, {\n  ComponentProps,\n  ForwardedRef,\n  forwardRef,\n  RefObject,\n  useCallback,\n  useEffect,\n  useImperativeHandle,\n  useMemo,\n  useRef,\n  useState,\n} from \"react\";\n\nconst MAX_BALLS = 7;\nconst eachBallWidthEm = 1.2;\n\nconst CENTER_GUIDE_BALL = 1;\n\nexport enum PaginationIndicatorMode {\n  /** This will make the guide ball be kept on center  */\n  CENTERED,\n\n  /** This will make the guide ball move, while the indicator balls keep in place */\n  START,\n}\nexport function PaginationIndicatorView({\n  size,\n  page: currentPage,\n  pages: decimalPages,\n  className,\n  onClickPage,\n  mode = PaginationIndicatorMode.CENTERED,\n  infinite,\n}: {\n  size: number;\n  page: number;\n  pages: number;\n  className?: string;\n  onClickPage?: (page: number) => void;\n  mode?: PaginationIndicatorMode;\n  infinite?: boolean;\n}) {\n  const maxBalls = useMemo(() => (infinite ? 5 : MAX_BALLS), [infinite]);\n  const page = useMemo(() => {\n    const floor = Math.floor(decimalPages);\n    const modulus = decimalPages % floor;\n\n    if (currentPage > floor) {\n      const currentFloorModulus = currentPage % floor;\n      const equivalent = (currentFloorModulus * 100) / modulus;\n\n      return floor + equivalent / 100;\n    } else {\n      return currentPage;\n    }\n  }, [currentPage, decimalPages]);\n  const rand = useMemo(() => Math.random().toString(), []);\n  const pageIndex = page - 1;\n  const pages = useMemo(() => Math.ceil(decimalPages), [decimalPages]);\n  const numBalls = useMemo(() => {\n    const numBalls = pages >= maxBalls ? maxBalls : Math.ceil(pages);\n\n    return numBalls;\n  }, [pages]);\n\n  const indexForTheBallsCenter = useMemo(\n    () => (infinite ? numBalls - 5 : numBalls - 1) / 2,\n    [numBalls, infinite]\n  );\n  const balls = useMemo(() => {\n    const indexForLastPages = pages + 1 - indexForTheBallsCenter;\n    /**\n     * Is the page index (position of the center)\n     * after the first pages and\n     * before the last pages */\n    const isCenterPage =\n      numBalls >= maxBalls &&\n      pageIndex > indexForTheBallsCenter &&\n      pageIndex < indexForLastPages - 1;\n    let modulus =\n      pageIndex %\n      (1 + (indexForTheBallsCenter - Math.floor(indexForTheBallsCenter)));\n    const resetPageIndex = isCenterPage\n      ? indexForTheBallsCenter + modulus\n      : pages < maxBalls\n      ? pageIndex\n      : pageIndex >= indexForLastPages - 1\n      ? numBalls - (pages - pageIndex)\n      : pageIndex;\n    const left = eachBallWidthEm * resetPageIndex;\n    const { pushBallsToRightBy, pushBallsToLeftBy, pushGuideToRightBy } =\n      mode === PaginationIndicatorMode.CENTERED\n        ? {\n            pushBallsToRightBy: Math.min(pages, maxBalls) * eachBallWidthEm,\n            pushBallsToLeftBy: left,\n            pushGuideToRightBy: 0,\n          }\n        : {\n            pushBallsToRightBy: (eachBallWidthEm - 0.5) / 2,\n            pushBallsToLeftBy: 0,\n            pushGuideToRightBy: left,\n          };\n    let pushToLeft: number = 0;\n    return new Array(CENTER_GUIDE_BALL + numBalls)\n      .fill(undefined)\n      .map((_, i) => {\n        const isLastBall = i === numBalls - 1;\n        const isFirstBall = i === 0;\n\n        if (i === numBalls) {\n          const diameter = 0.45 * 2;\n          const padding = (eachBallWidthEm - diameter) / 2;\n          return (\n            <rect\n              fill=\"#fff\"\n              width={`${diameter}em`}\n              height={`${diameter}em`}\n              x={`${\n                pushBallsToRightBy - padding + pushGuideToRightBy - pushToLeft\n              }em`}\n              y={`${padding}em`}\n              rx={`${diameter / 2}em`}\n            />\n          );\n        }\n\n        const ballSize =\n          numBalls < maxBalls\n            ? 0.5\n            : page <= indexForTheBallsCenter + 1 && isLastBall\n            ? 0\n            : pageIndex >= indexForLastPages - 1 && isFirstBall\n            ? 0\n            : isCenterPage\n            ? isFirstBall\n              ? 0.5 - modulus * 0.5\n              : isLastBall\n              ? modulus * 0.5\n              : 0.5\n            : 0.5;\n\n        if (i === 0 && mode === PaginationIndicatorMode.START)\n          pushToLeft = (0.5 - ballSize) * 2.4;\n\n        return (\n          <rect\n            key={`guide-${i}`}\n            width={`${ballSize * 1.2}em`}\n            height={`${ballSize * 1.2}em`}\n            x={`${\n              pushBallsToRightBy +\n              i * eachBallWidthEm -\n              pushBallsToLeftBy -\n              pushToLeft\n            }em`}\n            y={`${(eachBallWidthEm - ballSize * 1.2) / 2}em`}\n            rx={`${(ballSize * 1.2) / 2}em`}\n            onClick={() => {\n              if (onClickPage) {\n                const pageClicked =\n                  (!isCenterPage\n                    ? pageIndex >= indexForLastPages - 1\n                      ? Math.floor(page) - resetPageIndex - 1\n                      : 0\n                    : Math.floor(page) - (indexForTheBallsCenter + 1)) +\n                  1 +\n                  i;\n                onClickPage(Math.round(pageClicked));\n              }\n            }}\n          />\n        );\n      });\n  }, [indexForTheBallsCenter, pageIndex, pages]);\n  const [guideBall, ...pageBalls] = balls.reverse();\n  let width = eachBallWidthEm * Math.min(pages, maxBalls) * 2;\n  if (mode === PaginationIndicatorMode.START) width /= 2;\n\n  return (\n    <svg\n      version=\"1.1\"\n      xmlns=\"http://www.w3.org/2000/svg\"\n      className={className}\n      style={{\n        width: `${width}em`,\n        minWidth: `${width}em`,\n        height: \"1.2em\",\n        fontSize: `${size}px`,\n      }}\n    >\n      <filter id={`goo-${rand}`}>\n        <feGaussianBlur in=\"SourceGraphic\" result=\"blur\" stdDeviation=\"5\" />\n        <feColorMatrix\n          in=\"blur\"\n          mode=\"matrix\"\n          values=\"1 0 0 0 0  0 1 0 0 0  0 0 1 0 0  0 0 0 18 -7\"\n          result=\"goo\"\n        />\n        <feBlend in2=\"goo\" in=\"SourceGraphic\" result=\"mix\" />\n      </filter>\n      <mask id={`mask-${rand}`}>\n        <g filter={`url(#${`goo-${rand}`})`} fill=\"#fff\">\n          {[pageBalls]}\n          {guideBall}\n        </g>\n      </mask>\n      <rect\n        x=\"0\"\n        y=\"0\"\n        mask={`url(#${`mask-${rand}`})`}\n        width=\"100%\"\n        height=\"100%\"\n        style={{ fill: \"var(--digital-blue)\" }}\n      ></rect>\n      {onClickPage && (\n        <g opacity={0} style={{ cursor: \"pointer\" }}>\n          {pageBalls}\n        </g>\n      )}\n    </svg>\n  );\n}\n\nexport function AnimatedPaginationIndicator(\n  props: ComponentProps<typeof PaginationIndicatorView> & {\n    duration: number;\n  }\n) {\n  const prevPage = useRef(props.page);\n  const [pageProgress, setPageProgress] = useState(props.page);\n  useEffect(() => {\n    const diff = props.page - prevPage.current;\n    const diffPerStep = diff / 60;\n\n    const interval = setInterval(() => {\n      setPageProgress((prev) => {\n        const next = prev + diffPerStep;\n        if (diff < 0) {\n          if (next <= props.page) {\n            clearInterval(interval);\n            return props.page;\n          }\n        } else {\n          if (next >= props.page) {\n            clearInterval(interval);\n            return props.page;\n          }\n        }\n        return Number(next.toFixed(2));\n      });\n    }, props.duration / 60);\n\n    return () => {\n      prevPage.current = props.page;\n      clearInterval(interval);\n    };\n  }, [props.page]);\n\n  return <PaginationIndicatorView {...props} page={pageProgress} />;\n}\n\nfunction _PaginationIndicator(\n  {\n    scrollableRef,\n    estimatedWidth,\n    size,\n    className = \"\",\n    onClickPage,\n    mode,\n    infinite,\n  }: {\n    scrollableRef: RefObject<HTMLDivElement>;\n    estimatedWidth?: number;\n    size: number;\n    className?: string;\n    onClickPage?: (page: number) => void;\n  } & Pick<ComponentProps<typeof PaginationIndicatorView>, \"mode\" | \"infinite\">,\n  ref: ForwardedRef<{\n    refreshPages: () => void;\n  }>\n) {\n  const [currentPage, setCurrentPage] = useState(1);\n\n  const [defs, setDefs] =\n    useState<{\n      pages: number;\n    }>();\n\n  const refreshPages = useCallback(() => {\n    if (!scrollableRef.current) return;\n    const maxWidth =\n      estimatedWidth === undefined\n        ? scrollableRef.current!.scrollWidth\n        : estimatedWidth;\n\n    const pages = maxWidth / scrollableRef.current!.clientWidth;\n    if (pages > 1)\n      setDefs({\n        pages: infinite ? pages + 2 : pages,\n      });\n  }, [estimatedWidth, infinite]);\n\n  useEffect(() => refreshPages(), [refreshPages]);\n\n  const updatePageIndicators = useCallback(\n    (target: HTMLDivElement, pages: number) => {\n      if (!scrollableRef.current) return;\n      const eachPageWidth = scrollableRef.current!.clientWidth;\n      const page = 1 + target.scrollLeft / eachPageWidth;\n      const lastPageProgress = Math.floor(pages) + 1;\n      const maximumProgress = pages + 1;\n\n      const diffToMax = maximumProgress - lastPageProgress;\n      const currentProgressOnDiff = page - lastPageProgress;\n\n      if (page > lastPageProgress) {\n        const p = lastPageProgress + currentProgressOnDiff / diffToMax;\n        setCurrentPage(p);\n      } else setCurrentPage(page);\n    },\n    []\n  );\n\n  useImperativeHandle(\n    ref,\n    () => ({\n      refreshPages,\n    }),\n    []\n  );\n\n  useEffect(() => {\n    if (!defs) return;\n    const el = scrollableRef.current!;\n    const onScroll = (e: Event) =>\n      updatePageIndicators(e.currentTarget as HTMLDivElement, defs.pages);\n    updatePageIndicators(el, defs.pages);\n    el.addEventListener(\"scroll\", onScroll, {\n      passive: true,\n    });\n    return () => {\n      el.removeEventListener(\"scroll\", onScroll);\n    };\n  }, [defs]);\n\n  const pages = useMemo(() => (defs ? defs.pages : undefined), [defs]);\n\n  return !pages ? null : (\n    <PaginationIndicatorView\n      pages={pages}\n      page={currentPage}\n      size={size}\n      className={className}\n      onClickPage={onClickPage}\n      mode={mode}\n      infinite={infinite}\n    />\n  );\n}\n\n/**\n * A cool component to indicate how many pages are\n **/\n/**\n * A pagination indicator component that displays the current page\n * and total number of pages using animated circular indicators.\n * It updates visually when scrolling through pages.\n */\nconst PaginationIndicator = forwardRef(_PaginationIndicator);\nexport default PaginationIndicator;\n"],"mappings":"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"}

package/dist/components/PaginationIndicator/index.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {};
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function () {
+    return _PaginationIndicator.default;
+  }
+});
+var _PaginationIndicator = _interopRequireWildcard(require("./PaginationIndicator"));
+Object.keys(_PaginationIndicator).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _PaginationIndicator[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _PaginationIndicator[key];
+    }
+  });
+});
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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