@qsxy/element-plus-react 1.0.0-next.8 → 1.0.1

package/dist/Carousel/hooks/useCarousel.js

@@ -1,96 +1,112 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/Carousel/hooks/useCarousel.ts
-var useCarousel_exports = {};
-__export(useCarousel_exports, {
-  useCarousel: () => useCarousel
-});
-module.exports = __toCommonJS(useCarousel_exports);
-var import_ahooks = require("ahooks");
-var import_throttle = __toESM(require("lodash/throttle"));
-var import_react = require("react");
-var import_base = require("../../Util/base");
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _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(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _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(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+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(arr) { if (Array.isArray(arr)) return arr; }
+import { usePrevious } from 'ahooks';
+import throttle from 'lodash/throttle';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { isString, warning } from "../../Util/base";
 var THROTTLE_TIME = 300;
-var useCarousel = (props) => {
-  const { direction, arrow, height, type, autoplay, loop, interval, pauseOnHover, trigger, initialIndex, onChange } = props;
-  const [items, setItem] = (0, import_react.useState)([]);
-  const addItem = (item) => setItem((pre) => [...pre, item]);
-  const removeItem = (uid) => setItem((pre) => pre.filter((children) => children.uid !== uid));
-  const [activeIndex, setActiveIndex] = (0, import_react.useState)(-1);
-  const [hover, setHover] = (0, import_react.useState)(false);
-  const [containerHeight, setHeight] = (0, import_react.useState)(0);
-  const [isTransitioning, setIsTransitioning] = (0, import_react.useState)(false);
-  const preActiveIndex = (0, import_ahooks.usePrevious)(activeIndex);
-  const timer = (0, import_react.useRef)(null);
-  const root = (0, import_react.useRef)();
-  const isItemsTwoLength = (0, import_react.useRef)(true);
-  const isTransition = (0, import_react.useRef)(false);
-  const resizeObserver = (0, import_react.useRef)();
-  const isFirstCall = (0, import_react.useRef)(true);
-  const itemLen = (0, import_react.useRef)(0);
-  const activeIndexRef = (0, import_react.useRef)(-1);
-  const isVertical = (0, import_react.useMemo)(() => direction === "vertical", [direction]);
-  const arrowDisplay = (0, import_react.useMemo)(() => arrow !== "never" && !isVertical, [arrow, isVertical]);
-  const hasLabel = (0, import_react.useMemo)(() => {
-    return items.some((item) => {
-      var _a, _b, _c;
-      return ((_c = (_b = (_a = item.props) == null ? void 0 : _a.label) == null ? void 0 : _b.toString()) == null ? void 0 : _c.length) > 0;
+export var useCarousel = function useCarousel(props) {
+  var direction = props.direction,
+    arrow = props.arrow,
+    height = props.height,
+    type = props.type,
+    autoplay = props.autoplay,
+    loop = props.loop,
+    interval = props.interval,
+    pauseOnHover = props.pauseOnHover,
+    trigger = props.trigger,
+    initialIndex = props.initialIndex,
+    onChange = props.onChange;
+  var _useState = useState([]),
+    _useState2 = _slicedToArray(_useState, 2),
+    items = _useState2[0],
+    setItem = _useState2[1];
+  var addItem = function addItem(item) {
+    return setItem(function (pre) {
+      return [].concat(_toConsumableArray(pre), [item]);
+    });
+  };
+  var removeItem = function removeItem(uid) {
+    return setItem(function (pre) {
+      return pre.filter(function (children) {
+        return children.uid !== uid;
+      });
+    });
+  };
+  var _useState3 = useState(-1),
+    _useState4 = _slicedToArray(_useState3, 2),
+    activeIndex = _useState4[0],
+    setActiveIndex = _useState4[1];
+  var _useState5 = useState(false),
+    _useState6 = _slicedToArray(_useState5, 2),
+    hover = _useState6[0],
+    setHover = _useState6[1];
+  var _useState7 = useState(0),
+    _useState8 = _slicedToArray(_useState7, 2),
+    containerHeight = _useState8[0],
+    setHeight = _useState8[1];
+  var _useState9 = useState(false),
+    _useState10 = _slicedToArray(_useState9, 2),
+    isTransitioning = _useState10[0],
+    setIsTransitioning = _useState10[1];
+  var preActiveIndex = usePrevious(activeIndex);
+  var timer = useRef(null);
+  var root = useRef(null);
+  var isItemsTwoLength = useRef(true);
+  var isTransition = useRef(false);
+  var resizeObserver = useRef(null);
+  var isFirstCall = useRef(true);
+  var itemLen = useRef(0);
+  var activeIndexRef = useRef(-1);
+  var isVertical = useMemo(function () {
+    return direction === 'vertical';
+  }, [direction]);
+  var arrowDisplay = useMemo(function () {
+    return arrow !== 'never' && !isVertical;
+  }, [arrow, isVertical]);
+  var hasLabel = useMemo(function () {
+    return items.some(function (item) {
+      var _item$props;
+      return ((_item$props = item.props) === null || _item$props === void 0 || (_item$props = _item$props.label) === null || _item$props === void 0 || (_item$props = _item$props.toString()) === null || _item$props === void 0 ? void 0 : _item$props.length) > 0;
     });
   }, [items]);
-  const isCardType = (0, import_react.useMemo)(() => type === "card", [type]);
-  const containerStyle = (0, import_react.useMemo)(() => {
-    if (height !== "auto") {
+  var isCardType = useMemo(function () {
+    return type === 'card';
+  }, [type]);
+  var containerStyle = useMemo(function () {
+    if (height !== 'auto') {
       return {
-        height
+        height: height
       };
     }
     return {
       height: containerHeight,
-      overflow: "hidden"
+      overflow: 'hidden'
     };
   }, [containerHeight, height]);
-  const resetItemPosition = (0, import_react.useCallback)(
-    (oldIndex) => {
-      items.forEach((item, index) => {
-        item.translateItem(index, activeIndex, oldIndex);
-      });
-    },
-    [activeIndex, items]
-  );
-  const playSlides = (0, import_react.useCallback)(() => {
+  var resetItemPosition = useCallback(function (oldIndex) {
+    items.forEach(function (item, index) {
+      item.translateItem(index, activeIndex, oldIndex);
+    });
+  }, [activeIndex, items]);
+  var playSlides = useCallback(function () {
     if (!isFirstCall.current && !isTransition.current) {
       isTransition.current = true;
       setIsTransitioning(true);
     }
     isFirstCall.current = false;
     if (activeIndexRef.current < itemLen.current - 1) {
-      setActiveIndex((pre) => pre + 1);
+      setActiveIndex(function (pre) {
+        return pre + 1;
+      });
     } else if (loop) {
       setActiveIndex(0);
     } else {
@@ -98,150 +114,138 @@ var useCarousel = (props) => {
       setIsTransitioning(false);
     }
   }, [loop]);
-  const startTimer = (0, import_react.useCallback)(() => {
+  var startTimer = useCallback(function () {
     if (interval <= 0 || !autoplay || timer.current) {
       return;
     }
-    timer.current = setInterval(() => playSlides(), interval);
+    timer.current = setInterval(function () {
+      return playSlides();
+    }, interval);
   }, [autoplay, interval, playSlides]);
-  const pauseTimer = (0, import_react.useCallback)(() => {
+  var pauseTimer = useCallback(function () {
     if (timer.current) {
       clearInterval(timer.current);
       timer.current = null;
     }
   }, []);
-  const resetTimer = (0, import_react.useCallback)(() => {
+  var resetTimer = useCallback(function () {
     pauseTimer();
     if (!pauseOnHover) {
       startTimer();
     }
   }, [pauseOnHover, pauseTimer, startTimer]);
-  const setActiveItem = (0, import_react.useCallback)(
-    (index) => {
+  var setActiveItem = useCallback(function (index) {
+    if (!isFirstCall.current) {
+      isTransition.current = true;
+      setIsTransitioning(true);
+    }
+    isFirstCall.current = false;
+    if (isString(index)) {
+      var filteredItems = items.filter(function (item) {
+        return item.props.name === index;
+      });
+      if (filteredItems.length > 0) {
+        index = items.indexOf(filteredItems[0]);
+      }
+    }
+    index = Number(index);
+    if (Number.isNaN(index) || index !== Math.floor(index)) {
+      warning(false, 'component ElCarouselItem: index must be integer.');
+      return;
+    }
+    var itemCount = items.length;
+    var oldIndex = activeIndex;
+    if (index < 0) {
+      setActiveIndex(loop ? itemCount - 1 : 0);
+    } else if (index >= itemCount) {
+      setActiveIndex(loop ? 0 : itemCount - 1);
+    } else {
+      setActiveIndex(index);
+    }
+    if (oldIndex === activeIndex) {
+      resetItemPosition(oldIndex);
+    }
+    resetTimer();
+  }, [activeIndex, isFirstCall, items, loop, resetItemPosition, resetTimer]);
+  var throttledArrowClick = useCallback(function (index) {
+    setActiveItem(index);
+  }, [setActiveItem]);
+  var handleIndicatorHover = useCallback(function (index) {
+    if (trigger === 'hover' && index !== activeIndex) {
+      setActiveIndex(index);
       if (!isFirstCall.current) {
         isTransition.current = true;
         setIsTransitioning(true);
       }
-      isFirstCall.current = false;
-      if ((0, import_base.isString)(index)) {
-        const filteredItems = items.filter((item) => item.props.name === index);
-        if (filteredItems.length > 0) {
-          index = items.indexOf(filteredItems[0]);
-        }
-      }
-      index = Number(index);
-      if (Number.isNaN(index) || index !== Math.floor(index)) {
-        (0, import_base.warning)(false, "component ElCarouselItem: index must be integer.");
-        return;
-      }
-      const itemCount = items.length;
-      const oldIndex = activeIndex;
-      if (index < 0) {
-        setActiveIndex(loop ? itemCount - 1 : 0);
-      } else if (index >= itemCount) {
-        setActiveIndex(loop ? 0 : itemCount - 1);
-      } else {
-        setActiveIndex(index);
-      }
-      if (oldIndex === activeIndex) {
-        resetItemPosition(oldIndex);
-      }
-      resetTimer();
-    },
-    [activeIndex, isFirstCall, items, loop, resetItemPosition, resetTimer]
-  );
-  const throttledArrowClick = (0, import_react.useCallback)(
-    (index) => {
-      setActiveItem(index);
-    },
-    [setActiveItem]
-  );
-  const handleIndicatorHover = (0, import_react.useCallback)(
-    (index) => {
-      if (trigger === "hover" && index !== activeIndex) {
-        setActiveIndex(index);
-        if (!isFirstCall.current) {
-          isTransition.current = true;
-          setIsTransitioning(true);
-        }
-      }
-    },
-    [activeIndex, isFirstCall, trigger]
-  );
-  const throttledIndicatorHover = (0, import_react.useCallback)(
-    (index) => {
-      handleIndicatorHover(index);
-    },
-    [handleIndicatorHover]
-  );
-  const isTwoLengthShow = (0, import_react.useCallback)(
-    (index) => {
-      if (!isItemsTwoLength.current) {
-        return true;
-      }
-      return activeIndex <= 1 ? index <= 1 : index > 1;
-    },
-    [activeIndex]
-  );
-  const itemInStage = (0, import_react.useCallback)(
-    (item, index) => {
-      var _a, _b, _c, _d;
-      const itemCount = items.length;
-      if (itemCount === 0 || !item.states.inStage) {
-        return false;
-      }
-      const nextItemIndex = index + 1;
-      const prevItemIndex = index - 1;
-      const lastItemIndex = itemCount - 1;
-      const isLastItemActive = items[lastItemIndex].states.active;
-      const isFirstItemActive = items[0].states.active;
-      const isNextItemActive = (_b = (_a = items[nextItemIndex]) == null ? void 0 : _a.states) == null ? void 0 : _b.active;
-      const isPrevItemActive = (_d = (_c = items[prevItemIndex]) == null ? void 0 : _c.states) == null ? void 0 : _d.active;
-      if (index === lastItemIndex && isFirstItemActive || isNextItemActive) {
-        return "left";
-      } else if (index === 0 && isLastItemActive || isPrevItemActive) {
-        return "right";
-      }
+    }
+  }, [activeIndex, isFirstCall, trigger]);
+  var throttledIndicatorHover = useCallback(function (index) {
+    handleIndicatorHover(index);
+  }, [handleIndicatorHover]);
+  var isTwoLengthShow = useCallback(function (index) {
+    if (!isItemsTwoLength.current) {
+      return true;
+    }
+    return activeIndex <= 1 ? index <= 1 : index > 1;
+  }, [activeIndex]);
+  var itemInStage = useCallback(function (item, index) {
+    var _items$nextItemIndex, _items$prevItemIndex;
+    var itemCount = items.length;
+    if (itemCount === 0 || !item.states.inStage) {
       return false;
-    },
-    [items]
-  );
-  const handleMouseEnter = (0, import_react.useCallback)(() => {
+    }
+    var nextItemIndex = index + 1;
+    var prevItemIndex = index - 1;
+    var lastItemIndex = itemCount - 1;
+    var isLastItemActive = items[lastItemIndex].states.active;
+    var isFirstItemActive = items[0].states.active;
+    var isNextItemActive = (_items$nextItemIndex = items[nextItemIndex]) === null || _items$nextItemIndex === void 0 || (_items$nextItemIndex = _items$nextItemIndex.states) === null || _items$nextItemIndex === void 0 ? void 0 : _items$nextItemIndex.active;
+    var isPrevItemActive = (_items$prevItemIndex = items[prevItemIndex]) === null || _items$prevItemIndex === void 0 || (_items$prevItemIndex = _items$prevItemIndex.states) === null || _items$prevItemIndex === void 0 ? void 0 : _items$prevItemIndex.active;
+    if (index === lastItemIndex && isFirstItemActive || isNextItemActive) {
+      return 'left';
+    } else if (index === 0 && isLastItemActive || isPrevItemActive) {
+      return 'right';
+    }
+    return false;
+  }, [items]);
+  var handleMouseEnter = useCallback(function () {
     setHover(true);
     if (pauseOnHover) {
       pauseTimer();
     }
   }, [pauseOnHover, pauseTimer]);
-  const handleMouseLeave = (0, import_react.useCallback)(() => {
+  var handleMouseLeave = useCallback(function () {
     setHover(false);
     startTimer();
   }, [startTimer]);
-  const handleTransitionEnd = (0, import_react.useCallback)(() => {
+  var handleTransitionEnd = useCallback(function () {
     isTransition.current = false;
     setIsTransitioning(false);
   }, []);
-  const handleButtonEnter = (0, import_react.useCallback)(
-    (_arrow) => {
-      if (isVertical) {
-        return;
+  var handleButtonEnter = useCallback(function (_arrow) {
+    if (isVertical) {
+      return;
+    }
+    items.forEach(function (item, index) {
+      // @ts-ignore
+      if (_arrow === itemInStage(item, index)) {
+        item.setState({
+          hover: true
+        });
       }
-      items.forEach((item, index) => {
-        if (_arrow === itemInStage(item, index)) {
-          item.setState({ hover: true });
-        }
-      });
-    },
-    [isVertical, itemInStage, items]
-  );
-  const handleButtonLeave = (0, import_react.useCallback)(() => {
+    });
+  }, [isVertical, itemInStage, items]);
+  var handleButtonLeave = useCallback(function () {
     if (isVertical) {
       return;
     }
-    items.forEach((item) => {
-      item.setState({ hover: false });
+    items.forEach(function (item) {
+      item.setState({
+        hover: false
+      });
     });
   }, [isVertical, items]);
-  const handleIndicatorClick = (index) => {
+  var handleIndicatorClick = function handleIndicatorClick(index) {
     if (index !== activeIndex) {
       if (!isFirstCall.current) {
         isTransition.current = true;
@@ -250,99 +254,120 @@ var useCarousel = (props) => {
     }
     setActiveIndex(index);
   };
-  const prev = (0, import_react.useCallback)(() => {
+  var prev = useCallback(function () {
     setActiveItem(activeIndex - 1);
   }, [activeIndex, setActiveItem]);
-  const next = (0, import_react.useCallback)(() => {
+  var next = useCallback(function () {
     setActiveItem(activeIndex + 1);
   }, [activeIndex, setActiveItem]);
-  const setContainerHeight = (0, import_react.useCallback)(
-    (_height) => {
-      if (height !== "auto") {
-        return;
-      }
-      setHeight(_height);
-    },
-    [height]
-  );
-  (0, import_react.useEffect)(() => {
+  var setContainerHeight = useCallback(function (_height) {
+    if (height !== 'auto') {
+      return;
+    }
+    setHeight(_height);
+  }, [height]);
+
+  // const PlaceholderItem=() =>{
+  //     // fix: https://github.com/element-plus/element-plus/issues/12139
+  //     const defaultSlots = slots.default?.();
+  //     if (!defaultSlots) return null;
+
+  //     const flatSlots = flattedChildren(defaultSlots);
+
+  //     const normalizeSlots = flatSlots.filter(slot => {
+  //         return isVNode(slot) && (slot.type as any).name === CAROUSEL_ITEM_NAME;
+  //     });
+
+  //     if (normalizeSlots?.length === 2 && loop && !isCardType) {
+  //         isItemsTwoLength = true;
+  //         return normalizeSlots;
+  //     }
+  //     isItemsTwoLength = false;
+  //     return null;
+  // }
+
+  useEffect(function () {
     activeIndexRef.current = activeIndex;
     resetItemPosition(preActiveIndex);
-    let current, _prev;
+    var current, _prev;
     if (isItemsTwoLength.current) {
       current = activeIndex % 2;
       _prev = preActiveIndex % 2;
     }
     if (preActiveIndex > -1) {
-      onChange == null ? void 0 : onChange(current, _prev);
+      onChange === null || onChange === void 0 || onChange(current, _prev);
     }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [activeIndex]);
-  (0, import_react.useEffect)(() => {
+  useEffect(function () {
     setActiveItem(activeIndex);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [loop]);
-  (0, import_react.useEffect)(() => {
+  useEffect(function () {
     resetTimer();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [interval]);
-  (0, import_react.useEffect)(() => {
+  useEffect(function () {
     if (items.length > 0) {
       setActiveItem(initialIndex);
     }
     itemLen.current = items.length;
-    isItemsTwoLength.current = (items == null ? void 0 : items.length) === 2 && props.loop && !isCardType;
+    isItemsTwoLength.current = (items === null || items === void 0 ? void 0 : items.length) === 2 && props.loop && !isCardType;
+    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [items]);
-  (0, import_react.useEffect)(() => {
+  useEffect(function () {
     if (autoplay) {
       startTimer();
     } else {
       pauseTimer();
     }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [autoplay, items.length]);
-  (0, import_react.useEffect)(() => {
+  useEffect(function () {
     if (root.current) {
-      resizeObserver.current = new ResizeObserver(() => {
+      resizeObserver.current = new ResizeObserver(function () {
         resetItemPosition();
       });
       resizeObserver.current.observe(root.current);
       startTimer();
     }
-    return () => {
+    return function () {
       pauseTimer();
       if (resizeObserver.current) {
         resizeObserver.current.disconnect();
       }
     };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
   return {
-    items,
-    addItem,
-    removeItem,
-    setContainerHeight,
-    root,
-    activeIndex,
-    arrowDisplay,
-    hasLabel,
-    hover,
-    isCardType,
-    isTransitioning,
-    isVertical,
-    containerStyle,
-    isItemsTwoLength,
-    handleButtonEnter,
-    handleTransitionEnd,
-    handleButtonLeave,
-    handleIndicatorClick,
-    handleMouseEnter,
-    handleMouseLeave,
-    setActiveItem,
-    prev,
-    next,
+    items: items,
+    addItem: addItem,
+    removeItem: removeItem,
+    setContainerHeight: setContainerHeight,
+    root: root,
+    activeIndex: activeIndex,
+    arrowDisplay: arrowDisplay,
+    hasLabel: hasLabel,
+    hover: hover,
+    isCardType: isCardType,
+    isTransitioning: isTransitioning,
+    isVertical: isVertical,
+    containerStyle: containerStyle,
+    isItemsTwoLength: isItemsTwoLength,
+    handleButtonEnter: handleButtonEnter,
+    handleTransitionEnd: handleTransitionEnd,
+    handleButtonLeave: handleButtonLeave,
+    handleIndicatorClick: handleIndicatorClick,
+    handleMouseEnter: handleMouseEnter,
+    handleMouseLeave: handleMouseLeave,
+    setActiveItem: setActiveItem,
+    prev: prev,
+    next: next,
     // PlaceholderItem,
-    isTwoLengthShow,
-    throttledArrowClick: (0, import_throttle.default)(throttledArrowClick, THROTTLE_TIME, { trailing: true }),
-    throttledIndicatorHover: (0, import_throttle.default)(throttledIndicatorHover, THROTTLE_TIME)
+    isTwoLengthShow: isTwoLengthShow,
+    throttledArrowClick: throttle(throttledArrowClick, THROTTLE_TIME, {
+      trailing: true
+    }),
+    throttledIndicatorHover: throttle(throttledIndicatorHover, THROTTLE_TIME)
   };
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  useCarousel
-});
+};