@qsxy/element-plus-react 1.0.0-next.4 → 1.0.0-next.7

package/dist/Carousel/hooks/useCarousel.js

@@ -0,0 +1,348 @@
+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");
+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;
+    });
+  }, [items]);
+  const isCardType = (0, import_react.useMemo)(() => type === "card", [type]);
+  const containerStyle = (0, import_react.useMemo)(() => {
+    if (height !== "auto") {
+      return {
+        height
+      };
+    }
+    return {
+      height: containerHeight,
+      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)(() => {
+    if (!isFirstCall.current && !isTransition.current) {
+      isTransition.current = true;
+      setIsTransitioning(true);
+    }
+    isFirstCall.current = false;
+    if (activeIndexRef.current < itemLen.current - 1) {
+      setActiveIndex((pre) => pre + 1);
+    } else if (loop) {
+      setActiveIndex(0);
+    } else {
+      isTransition.current = false;
+      setIsTransitioning(false);
+    }
+  }, [loop]);
+  const startTimer = (0, import_react.useCallback)(() => {
+    if (interval <= 0 || !autoplay || timer.current) {
+      return;
+    }
+    timer.current = setInterval(() => playSlides(), interval);
+  }, [autoplay, interval, playSlides]);
+  const pauseTimer = (0, import_react.useCallback)(() => {
+    if (timer.current) {
+      clearInterval(timer.current);
+      timer.current = null;
+    }
+  }, []);
+  const resetTimer = (0, import_react.useCallback)(() => {
+    pauseTimer();
+    if (!pauseOnHover) {
+      startTimer();
+    }
+  }, [pauseOnHover, pauseTimer, startTimer]);
+  const setActiveItem = (0, import_react.useCallback)(
+    (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";
+      }
+      return false;
+    },
+    [items]
+  );
+  const handleMouseEnter = (0, import_react.useCallback)(() => {
+    setHover(true);
+    if (pauseOnHover) {
+      pauseTimer();
+    }
+  }, [pauseOnHover, pauseTimer]);
+  const handleMouseLeave = (0, import_react.useCallback)(() => {
+    setHover(false);
+    startTimer();
+  }, [startTimer]);
+  const handleTransitionEnd = (0, import_react.useCallback)(() => {
+    isTransition.current = false;
+    setIsTransitioning(false);
+  }, []);
+  const handleButtonEnter = (0, import_react.useCallback)(
+    (_arrow) => {
+      if (isVertical) {
+        return;
+      }
+      items.forEach((item, index) => {
+        if (_arrow === itemInStage(item, index)) {
+          item.setState({ hover: true });
+        }
+      });
+    },
+    [isVertical, itemInStage, items]
+  );
+  const handleButtonLeave = (0, import_react.useCallback)(() => {
+    if (isVertical) {
+      return;
+    }
+    items.forEach((item) => {
+      item.setState({ hover: false });
+    });
+  }, [isVertical, items]);
+  const handleIndicatorClick = (index) => {
+    if (index !== activeIndex) {
+      if (!isFirstCall.current) {
+        isTransition.current = true;
+        setIsTransitioning(true);
+      }
+    }
+    setActiveIndex(index);
+  };
+  const prev = (0, import_react.useCallback)(() => {
+    setActiveItem(activeIndex - 1);
+  }, [activeIndex, setActiveItem]);
+  const next = (0, import_react.useCallback)(() => {
+    setActiveItem(activeIndex + 1);
+  }, [activeIndex, setActiveItem]);
+  const setContainerHeight = (0, import_react.useCallback)(
+    (_height) => {
+      if (height !== "auto") {
+        return;
+      }
+      setHeight(_height);
+    },
+    [height]
+  );
+  (0, import_react.useEffect)(() => {
+    activeIndexRef.current = activeIndex;
+    resetItemPosition(preActiveIndex);
+    let current, _prev;
+    if (isItemsTwoLength.current) {
+      current = activeIndex % 2;
+      _prev = preActiveIndex % 2;
+    }
+    if (preActiveIndex > -1) {
+      onChange == null ? void 0 : onChange(current, _prev);
+    }
+  }, [activeIndex]);
+  (0, import_react.useEffect)(() => {
+    setActiveItem(activeIndex);
+  }, [loop]);
+  (0, import_react.useEffect)(() => {
+    resetTimer();
+  }, [interval]);
+  (0, import_react.useEffect)(() => {
+    if (items.length > 0) {
+      setActiveItem(initialIndex);
+    }
+    itemLen.current = items.length;
+    isItemsTwoLength.current = (items == null ? void 0 : items.length) === 2 && props.loop && !isCardType;
+  }, [items]);
+  (0, import_react.useEffect)(() => {
+    if (autoplay) {
+      startTimer();
+    } else {
+      pauseTimer();
+    }
+  }, [autoplay, items.length]);
+  (0, import_react.useEffect)(() => {
+    if (root.current) {
+      resizeObserver.current = new ResizeObserver(() => {
+        resetItemPosition();
+      });
+      resizeObserver.current.observe(root.current);
+      startTimer();
+    }
+    return () => {
+      pauseTimer();
+      if (resizeObserver.current) {
+        resizeObserver.current.disconnect();
+      }
+    };
+  }, []);
+  return {
+    items,
+    addItem,
+    removeItem,
+    setContainerHeight,
+    root,
+    activeIndex,
+    arrowDisplay,
+    hasLabel,
+    hover,
+    isCardType,
+    isTransitioning,
+    isVertical,
+    containerStyle,
+    isItemsTwoLength,
+    handleButtonEnter,
+    handleTransitionEnd,
+    handleButtonLeave,
+    handleIndicatorClick,
+    handleMouseEnter,
+    handleMouseLeave,
+    setActiveItem,
+    prev,
+    next,
+    // PlaceholderItem,
+    isTwoLengthShow,
+    throttledArrowClick: (0, import_throttle.default)(throttledArrowClick, THROTTLE_TIME, { trailing: true }),
+    throttledIndicatorHover: (0, import_throttle.default)(throttledIndicatorHover, THROTTLE_TIME)
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useCarousel
+});

package/dist/Carousel/hooks/useCarouselItem.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { CarouselItemProps, CarouselItemStates } from '../typings';
+export declare const useCarouselItem: (props: CarouselItemProps) => {
+    carouselItemRef: import("react").MutableRefObject<HTMLDivElement>;
+    state: CarouselItemStates;
+    setState: (_state: Partial<CarouselItemStates>) => void;
+    handleItemClick: () => void;
+};

package/dist/Carousel/hooks/useCarouselItem.js

@@ -0,0 +1,161 @@
+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/useCarouselItem.ts
+var useCarouselItem_exports = {};
+__export(useCarouselItem_exports, {
+  useCarouselItem: () => useCarouselItem
+});
+module.exports = __toCommonJS(useCarouselItem_exports);
+var import_omit = __toESM(require("lodash/omit"));
+var import_react = require("react");
+var import_CarouselContext = require("../CarouselContext");
+var useCarouselItem = (props) => {
+  const { isCardType, loop, isVertical, cardScale, root, items, addItem, removeItem, setActiveItem, setContainerHeight } = (0, import_CarouselContext.useCarouselContext)();
+  const id = (0, import_react.useId)();
+  const carouselItemRef = (0, import_react.useRef)();
+  const ref = (0, import_react.useRef)();
+  const reducer = (state2, action) => {
+    switch (action.type) {
+      case "setState":
+        return { ...state2, ...action.payload };
+      default:
+        return state2;
+    }
+  };
+  const [state, dispatch] = (0, import_react.useReducer)(reducer, { ready: false, hover: false, translate: 0, scale: 1, animating: false, active: false, inStage: false });
+  const setState = (_state) => dispatch({
+    type: "setState",
+    payload: _state
+  });
+  const calcCardTranslate = (0, import_react.useCallback)(
+    (index, activeIndex, inStage) => {
+      var _a, _b;
+      const parentWidth = isVertical ? ((_a = root.current) == null ? void 0 : _a.offsetHeight) || 0 : ((_b = root.current) == null ? void 0 : _b.offsetWidth) || 0;
+      if (inStage) {
+        return parentWidth * ((2 - cardScale) * (index - activeIndex) + 1) / 4;
+      } else if (index < activeIndex) {
+        return -(1 + cardScale) * parentWidth / 4;
+      } else {
+        return (3 + cardScale) * parentWidth / 4;
+      }
+    },
+    [cardScale, isVertical, root]
+  );
+  const calcTranslate = (0, import_react.useCallback)(
+    (index, activeIndex) => {
+      const rootEl = root.current;
+      if (!rootEl) {
+        return 0;
+      }
+      const distance = (isVertical ? rootEl.offsetHeight : rootEl.offsetWidth) || 0;
+      return distance * (index - activeIndex);
+    },
+    [isVertical, root]
+  );
+  const translateItem = (0, import_react.useCallback)(
+    (index, activeIndex, oldIndex) => {
+      const carouselItemLength = items.length ?? Number.NaN;
+      const isActive = index === activeIndex;
+      if (!isCardType && oldIndex != void 0) {
+        setState({ animating: isActive || index === oldIndex });
+      }
+      if (!isActive && carouselItemLength > 2 && loop) {
+        index = processIndex(index, activeIndex, carouselItemLength);
+      }
+      setState({ active: isActive });
+      if (isCardType) {
+        const inStage = Math.round(Math.abs(index - activeIndex)) <= 1;
+        setState({
+          inStage,
+          translate: calcCardTranslate(index, activeIndex, inStage),
+          scale: isActive ? 1 : cardScale
+        });
+      } else {
+        setState({
+          translate: calcTranslate(index, activeIndex)
+        });
+      }
+      setState({
+        ready: true
+      });
+      if (isActive && carouselItemRef.current) {
+        setContainerHeight(carouselItemRef.current.offsetHeight);
+      }
+    },
+    [calcCardTranslate, calcTranslate, cardScale, isCardType, items, loop, setContainerHeight]
+  );
+  const handleItemClick = (0, import_react.useCallback)(() => {
+    if (isCardType) {
+      const index = items.findIndex(({ uid }) => uid === id);
+      setActiveItem(index);
+    }
+  }, [id, isCardType, items, setActiveItem]);
+  (0, import_react.useImperativeHandle)(ref, () => ({
+    translateItem
+  }));
+  (0, import_react.useEffect)(() => {
+    addItem({
+      props: (0, import_omit.default)(props, "children"),
+      states: state,
+      setState,
+      uid: id,
+      translateItem: (...args) => {
+        var _a;
+        return (_a = ref == null ? void 0 : ref.current) == null ? void 0 : _a.translateItem(...args);
+      }
+    });
+    return () => removeItem(id);
+  }, []);
+  return {
+    carouselItemRef,
+    state,
+    setState,
+    handleItemClick
+  };
+};
+var processIndex = (index, activeIndex, length) => {
+  const lastItemIndex = length - 1;
+  const prevItemIndex = activeIndex - 1;
+  const nextItemIndex = activeIndex + 1;
+  const halfItemIndex = length / 2;
+  if (activeIndex === 0 && index === lastItemIndex) {
+    return -1;
+  } else if (activeIndex === lastItemIndex && index === 0) {
+    return length;
+  } else if (index < prevItemIndex && activeIndex - index >= halfItemIndex) {
+    return length + 1;
+  } else if (index > nextItemIndex && index - activeIndex >= halfItemIndex) {
+    return -2;
+  }
+  return index;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useCarouselItem
+});

package/dist/Carousel/index.d.ts

@@ -0,0 +1,3 @@
+export { default as Carousel } from './Carousel';
+export { default as CarouselItem } from './CarouselItem';
+export type { CarouselItemProps, CarouselProps, CarouselRef } from './typings';

package/dist/{VirtualList → Carousel}/index.js

@@ -26,14 +26,17 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/VirtualList/index.ts
-var VirtualList_exports = {};
-__export(VirtualList_exports, {
-  VirtualList: () => import_VirtualList.default
+// src/Carousel/index.ts
+var Carousel_exports = {};
+__export(Carousel_exports, {
+  Carousel: () => import_Carousel.default,
+  CarouselItem: () => import_CarouselItem.default
 });
-module.exports = __toCommonJS(VirtualList_exports);
-var import_VirtualList = __toESM(require("./VirtualList"));
+module.exports = __toCommonJS(Carousel_exports);
+var import_Carousel = __toESM(require("./Carousel"));
+var import_CarouselItem = __toESM(require("./CarouselItem"));
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  VirtualList
+  Carousel,
+  CarouselItem
 });

package/dist/Carousel/typings.d.ts

@@ -0,0 +1,83 @@
+import { RefObject } from 'react';
+import { BaseProps, NativeProps } from '../types/common';
+export interface CarouselProps extends BaseProps, NativeProps {
+    /** carousel 的高度	 */
+    height?: string | number;
+    /** 初始状态激活的幻灯片的索引，从 0 开始	 */
+    initialIndex?: number;
+    /** 指示器的触发方式 */
+    trigger?: 'hover' | 'click';
+    /** 是否自动切换 */
+    autoplay?: boolean;
+    /** 自动切换的时间间隔，单位为毫秒 */
+    interval?: number;
+    /** 指示器的位置 */
+    indicatorPosition?: '' | 'none' | 'outside';
+    /** 切换箭头的显示时机 */
+    arrow?: 'always' | 'hover' | 'never';
+    /** carousel 的类型 */
+    type?: '' | 'card';
+    /** 当 type 为 card时，二级卡的缩放大小 */
+    cardScale?: number;
+    /** 是否循环显示 */
+    loop?: boolean;
+    /** 展示的方向 */
+    direction?: 'horizontal' | 'vertical';
+    /** 鼠标悬浮时暂停自动切换 */
+    pauseOnHover?: boolean;
+    /** 添加动态模糊以给走马灯注入活力和流畅性。 */
+    motionBlur?: boolean;
+    /** 当前展示的幻灯片切换时触发，它有两个参数， 一个是新幻灯片的索引，另一个是旧幻灯片的索引 */
+    onChange?: (current: number, prev: number) => boolean;
+}
+export interface CarouselItemProps extends BaseProps, NativeProps<'--el-carousel-arrow-font-size' | '--el-carousel-arrow-size' | '--el-carousel-arrow-background' | '--el-carousel-arrow-hover-background' | '--el-carousel-indicator-width' | '--el-carousel-indicator-height' | '--el-carousel-indicator-padding-horizontal' | '--el-carousel-indicator-padding-vertical' | '--el-carousel-indicator-out-color'> {
+    /** 幻灯片的名字，可用作 setActiveItem 的参数 */
+    name?: string;
+    /** 该幻灯片所对应指示器的文本 */
+    label?: string;
+}
+export type CarouselRef = {
+    /** 当前幻灯片的索引 */
+    activeIndex?: number;
+    /** 手动切换幻灯片，传入需要切换的幻灯片的索引，从 0 开始；或相应 elCarouselItem 的 name 属性值 */
+    setActiveItem?: (index: string | number) => void;
+    /** 切换至上一张幻灯片 */
+    prev?: () => void;
+    /** 切换至下一张幻灯片 */
+    next?: () => void;
+};
+export type CarouselItemStates = {
+    hover: boolean;
+    translate: number;
+    scale: number;
+    active: boolean;
+    ready: boolean;
+    inStage: boolean;
+    animating: boolean;
+};
+export type CarouselItemContext = {
+    props: CarouselItemProps;
+    states: CarouselItemStates;
+    setState: (_state: Partial<CarouselItemStates>) => void;
+    uid: string;
+    translateItem: (index: number, activeIndex: number, oldIndex?: number) => void;
+};
+export type CarouselContextProps = {
+    root: RefObject<HTMLDivElement>;
+    isCardType: boolean;
+    isVertical: boolean;
+    items: CarouselItemContext[];
+    loop: boolean;
+    cardScale: number;
+    addItem: (child: CarouselItemContext) => void;
+    removeItem: (uid: string) => void;
+    setActiveItem: (index: number | string) => void;
+    setContainerHeight: (height: number) => void;
+};
+export interface CarouselItemAction {
+    type: 'setState';
+    payload: Partial<CarouselItemStates>;
+}
+export type CarouselItemRef = {
+    translateItem: (index: number, activeIndex: number, oldIndex?: number) => void;
+};

package/dist/{VirtualList/interface.js → Carousel/typings.js}

@@ -12,6 +12,6 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/VirtualList/interface.ts
-var interface_exports = {};
-module.exports = __toCommonJS(interface_exports);
+// src/Carousel/typings.ts
+var typings_exports = {};
+module.exports = __toCommonJS(typings_exports);