shineout 1.12.2 → 1.12.3

package/esm/AnimationList/AbsoluteList.js

@@ -0,0 +1,373 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import React, { Component } from 'react';
+import ReactDOM from 'react-dom';
+import classnames from 'classnames';
+import shallowEqual from '../utils/shallowEqual';
+import { compose } from '../utils/func';
+import { scrollConsumer } from '../Scroll/context';
+import { listClass } from './styles';
+import { docSize } from '../utils/dom/document';
+import { getRTLPosition } from '../utils/strings';
+import zIndexConsumer from '../Modal/context';
+import { isRTL } from '../config';
+import { addZoomListener, removeZoomListener } from '../utils/zoom';
+var PICKER_V_MARGIN = 4;
+var root;
+
+function initRoot() {
+  root = document.createElement('div');
+  root.className = listClass('root', isRTL() && 'rtl');
+  document.body.appendChild(root);
+}
+
+var getOverDocStyle = function getOverDocStyle(right) {
+  return right ? {
+    left: 0,
+    right: 'auto'
+  } : {
+    right: 0,
+    left: 'auto'
+  };
+};
+
+var listPosition = ['drop-down', 'drop-up'];
+var pickerPosition = ['left-bottom', 'left-top', 'right-bottom', 'right-top'];
+var dropdownPosition = ['bottom-left', 'bottom-right', 'top-left', 'top-right'];
+export default function (List) {
+  var AbsoluteList =
+  /*#__PURE__*/
+  function (_Component) {
+    _inheritsLoose(AbsoluteList, _Component);
+
+    function AbsoluteList(props) {
+      var _this;
+
+      _this = _Component.call(this, props) || this;
+
+      _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "state", {
+        overdoc: false
+      });
+
+      _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "lastStyle", void 0);
+
+      _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "container", void 0);
+
+      _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "element", void 0);
+
+      _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "ajustdoc", void 0);
+
+      _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "containerRect", void 0);
+
+      _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "containerScroll", void 0);
+
+      _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "el", void 0);
+
+      _this.handleRef = _this.handleRef.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+      if (!props.absolute) return _assertThisInitialized(_this);
+      _this.lastStyle = {};
+      if (!root) initRoot();
+      _this.container = typeof _this.props.absolute === 'function' ? _this.props.absolute() : root;
+      _this.element = document.createElement('div');
+      if (_this.container) _this.container.appendChild(_this.element);
+
+      if (props.getResetPosition) {
+        props.getResetPosition(_this.resetPosition.bind(_assertThisInitialized(_assertThisInitialized(_this))));
+      }
+
+      _this.zoomChangeHandler = _this.zoomChangeHandler.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+      return _this;
+    }
+
+    var _proto = AbsoluteList.prototype;
+
+    _proto.componentDidMount = function componentDidMount() {
+      if (this.props.absolute && !this.container) {
+        this.container = typeof this.props.absolute === 'function' ? this.props.absolute() : root;
+        this.container.appendChild(this.element);
+
+        if (this.props.focus) {
+          this.forceUpdate();
+        }
+      }
+
+      if (this.props.absolute) {
+        addZoomListener(this.zoomChangeHandler);
+      }
+    };
+
+    _proto.componentDidUpdate = function componentDidUpdate(prevProps) {
+      var _this2 = this;
+
+      if (!this.props.focus) this.ajustdoc = false;
+      if (shallowEqual(prevProps.value, this.props.value)) return;
+      setTimeout(function () {
+        _this2.forceUpdate();
+      });
+    };
+
+    _proto.componentWillUnmount = function componentWillUnmount() {
+      var absolute = this.props.absolute;
+      if (!absolute) return;
+      removeZoomListener(this.zoomChangeHandler);
+
+      if (this.container) {
+        if (this.element && this.element.parentNode) this.element.parentNode.removeChild(this.element);
+      }
+    };
+
+    _proto.getPosition = function getPosition(rect) {
+      var fixed = this.props.fixed;
+      var position = this.props.position;
+      var rtl = isRTL();
+      var style = {
+        position: 'absolute',
+        right: 'auto'
+      };
+
+      if (fixed) {
+        var widthKey = fixed === 'min' ? 'minWidth' : 'width';
+        style[widthKey] = rect.width;
+      }
+
+      if (dropdownPosition.includes(position)) {
+        position = position.split('-').reverse().join('-');
+      }
+
+      if (rtl) {
+        position = getRTLPosition(position);
+      }
+
+      var container = this.container;
+      var rootContainer = container === root || !container ? document.body : container;
+      var containerRect = rootContainer.getBoundingClientRect();
+      var containerScroll = {
+        left: rootContainer.scrollLeft,
+        top: rootContainer.scrollTop
+      };
+      this.containerRect = containerRect;
+      this.containerScroll = containerScroll;
+
+      if (listPosition.includes(position)) {
+        style.left = rect.left - containerRect.left + containerScroll.left;
+
+        if (isRTL()) {
+          style.right = containerRect.width - rect.width - style.left;
+          style.left = 'auto';
+        }
+
+        if (position === 'drop-down') {
+          style.top = rect.top - containerRect.top + rect.height + containerScroll.top;
+        } else {
+          style.bottom = -(rect.top - containerRect.top + containerScroll.top);
+        }
+      } else if (pickerPosition.includes(position)) {
+        var _position$split = position.split('-'),
+            h = _position$split[0],
+            v = _position$split[1];
+
+        if (h === 'left') {
+          style.left = rect.left - containerRect.left + containerScroll.left;
+        } else {
+          style.right = containerRect.width - rect.width - rect.left + containerRect.left - containerScroll.left;
+          style.left = 'auto';
+        }
+
+        if (v === 'bottom') {
+          style.top = rect.bottom - containerRect.top + containerScroll.top + PICKER_V_MARGIN;
+        } else {
+          style.top = rect.top - containerRect.top + containerScroll.top - PICKER_V_MARGIN;
+          style.transform = 'translateY(-100%)';
+        }
+      }
+
+      return style;
+    };
+
+    _proto.getStyle = function getStyle() {
+      var _this$props = this.props,
+          parentElement = _this$props.parentElement,
+          scrollElement = _this$props.scrollElement,
+          focus = _this$props.focus;
+      var lazyResult = {
+        focus: focus,
+        style: this.lastStyle
+      };
+      if (!focus) return lazyResult;
+      var style = {};
+
+      if (parentElement) {
+        var rect = parentElement.getBoundingClientRect();
+        var scrollRect = scrollElement ? scrollElement.getBoundingClientRect() : {};
+
+        if (rect.bottom < scrollRect.top || rect.top > scrollRect.bottom || rect.right < scrollRect.left || rect.left > scrollRect.right) {
+          return {
+            focus: false,
+            style: this.lastStyle
+          };
+        }
+
+        style = this.getPosition(rect);
+      }
+
+      if (shallowEqual(style, this.lastStyle)) return lazyResult;
+      this.lastStyle = style;
+      return {
+        focus: focus,
+        style: style
+      };
+    };
+
+    _proto.zoomChangeHandler = function zoomChangeHandler() {
+      if (this.props.focus) {
+        this.forceUpdate();
+      }
+    };
+
+    _proto.isRight = function isRight() {
+      var position = this.props.position;
+      var isRight = false;
+
+      if (position && position.indexOf('right') > 1) {
+        isRight = true;
+      }
+
+      if (isRTL()) {
+        isRight = !isRight;
+      }
+
+      return isRight;
+    };
+
+    _proto.resetPosition = function resetPosition(clean) {
+      var _this$props2 = this.props,
+          focus = _this$props2.focus,
+          parentElement = _this$props2.parentElement;
+      if (!this.el || !focus || this.ajustdoc && !clean) return;
+      var width = this.el.offsetWidth;
+      var pos = parentElement && parentElement.getBoundingClientRect() || {
+        left: 0,
+        right: 0
+      };
+      var containerRect = this.containerRect || {
+        left: 0,
+        width: 0
+      };
+      var containerScroll = this.containerScroll || {
+        left: 0
+      };
+      var overdoc;
+
+      if (this.isRight()) {
+        if (isRTL() && containerScroll.left) {
+          // this condition  the style left: 0 will not meet expect so not set overdoc
+          overdoc = false;
+        } else {
+          overdoc = pos.right - width < containerRect.left;
+        }
+      } else if (!isRTL() && containerScroll.left) {
+        // this condition  the style right: 0 will not meet expect so not set overdoc
+        overdoc = false;
+      } else {
+        overdoc = pos.left - containerRect.left + width + containerScroll.left > (containerRect.width || docSize.width);
+      }
+
+      if (this.state.overdoc === overdoc) return;
+      this.ajustdoc = true;
+      this.setState({
+        overdoc: overdoc
+      });
+    };
+
+    _proto.handleRef = function handleRef(ref) {
+      this.el = ref;
+    };
+
+    _proto.renderList = function renderList() {
+      var _this$props3 = this.props,
+          parentElement = _this$props3.parentElement,
+          absolute = _this$props3.absolute,
+          focus = _this$props3.focus,
+          rootClass = _this$props3.rootClass,
+          position = _this$props3.position,
+          scrollLeft = _this$props3.scrollLeft,
+          scrollTop = _this$props3.scrollTop,
+          scrollElement = _this$props3.scrollElement,
+          _this$props3$style = _this$props3.style,
+          style = _this$props3$style === void 0 ? {} : _this$props3$style,
+          zIndex = _this$props3.zIndex,
+          getResetPosition = _this$props3.getResetPosition,
+          ignore = _this$props3.autoAdapt,
+          props = _objectWithoutPropertiesLoose(_this$props3, ["parentElement", "absolute", "focus", "rootClass", "position", "scrollLeft", "scrollTop", "scrollElement", "style", "zIndex", "getResetPosition", "autoAdapt"]);
+
+      if (zIndex !== undefined) {
+        var parsed = parseInt(zIndex, 10);
+        if (!Number.isNaN(parsed)) style.zIndex = parsed;
+      }
+
+      var mergeStyle = Object.assign({}, style, this.state.overdoc ? getOverDocStyle(this.isRight()) : undefined);
+      return React.createElement(List, _extends({
+        getRef: this.handleRef
+      }, props, {
+        focus: focus,
+        style: mergeStyle
+      }));
+    };
+
+    _proto.render = function render() {
+      var _this3 = this;
+
+      var autoAdapt = this.props.autoAdapt;
+      setTimeout(function () {
+        _this3.resetPosition(autoAdapt);
+      });
+
+      if (!this.props.absolute) {
+        return this.renderList();
+      }
+
+      if (!this.container) return null;
+
+      var _this$props4 = this.props,
+          parentElement = _this$props4.parentElement,
+          rootClass = _this$props4.rootClass,
+          absolute = _this$props4.absolute,
+          position = _this$props4.position,
+          scrollLeft = _this$props4.scrollLeft,
+          scrollTop = _this$props4.scrollTop,
+          scrollElement = _this$props4.scrollElement,
+          autoClass = _this$props4.autoClass,
+          zIndex = _this$props4.zIndex,
+          getResetPosition = _this$props4.getResetPosition,
+          value = _this$props4.value,
+          ignore = _this$props4.autoAdapt,
+          props = _objectWithoutPropertiesLoose(_this$props4, ["parentElement", "rootClass", "absolute", "position", "scrollLeft", "scrollTop", "scrollElement", "autoClass", "zIndex", "getResetPosition", "value", "autoAdapt"]);
+
+      var mergeClass = classnames(listClass('absolute-wrapper'), rootClass, autoClass);
+
+      var _ref = props.focus ? this.getStyle() : {
+        style: this.lastStyle,
+        focus: undefined
+      },
+          focus = _ref.focus,
+          style = _ref.style;
+
+      this.element.className = mergeClass;
+      var mergeStyle = Object.assign({}, style, props.style, this.state.overdoc ? getOverDocStyle(this.isRight()) : undefined);
+      if (zIndex || typeof zIndex === 'number') mergeStyle.zIndex = parseInt(zIndex, 10);
+      return ReactDOM.createPortal(React.createElement(List, _extends({
+        getRef: this.handleRef
+      }, props, {
+        focus: focus,
+        style: mergeStyle
+      })), this.element);
+    };
+
+    return AbsoluteList;
+  }(Component);
+
+  return compose(scrollConsumer, zIndexConsumer)(AbsoluteList);
+}

package/esm/AnimationList/LazyList.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="react" />
+import { PureComponent } from '../component';
+import { LazyListProps } from './Props';
+import { ScrollFixedType } from '../Scroll/Props';
+interface LazyListState {
+    currentIndex: number;
+    scrollTop: number;
+    fixed: ScrollFixedType | '';
+}
+declare class LazyList<DataItem> extends PureComponent<LazyListProps<DataItem>, LazyListState> {
+    static defaultProps: {
+        itemsInView: number;
+        lineHeight: number;
+        data: never[];
+        colNum: number;
+    };
+    optionInner: HTMLDivElement;
+    lastScrollTop: number;
+    constructor(props: LazyListProps<DataItem>);
+    componentDidUpdate(prevProps: LazyListProps<DataItem>): void;
+    getScrollHeight(): number;
+    resetScrollTop(): void;
+    handleScroll(_x: number, y: number, _max: number, _bar: HTMLElement, _v: number, h: number, _pixelX?: number, pixelY?: number): void;
+    render(): JSX.Element;
+}
+export default LazyList;

package/esm/AnimationList/LazyList.js

@@ -0,0 +1,163 @@
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import React, { Fragment } from 'react';
+import { PureComponent } from '../component';
+import Scroll from '../Scroll';
+import { getKey } from '../utils/uid';
+import { setTranslate } from '../utils/dom/translate';
+var DefaultProps = {
+  itemsInView: 10,
+  lineHeight: 32,
+  data: [],
+  colNum: 1
+};
+
+var LazyList =
+/*#__PURE__*/
+function (_PureComponent) {
+  _inheritsLoose(LazyList, _PureComponent);
+
+  function LazyList(props) {
+    var _this;
+
+    _this = _PureComponent.call(this, props) || this;
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "optionInner", void 0);
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "lastScrollTop", void 0);
+
+    _this.state = {
+      currentIndex: 0,
+      scrollTop: 0,
+      fixed: ''
+    };
+    _this.handleScroll = _this.handleScroll.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    return _this;
+  }
+
+  var _proto = LazyList.prototype;
+
+  _proto.componentDidUpdate = function componentDidUpdate(prevProps) {
+    if (!this.props.stay && prevProps.data.length !== this.props.data.length) {
+      this.resetScrollTop();
+    }
+  };
+
+  _proto.getScrollHeight = function getScrollHeight() {
+    var _this$props = this.props,
+        _this$props$lineHeigh = _this$props.lineHeight,
+        lineHeight = _this$props$lineHeigh === void 0 ? DefaultProps.lineHeight : _this$props$lineHeigh,
+        data = _this$props.data,
+        _this$props$colNum = _this$props.colNum,
+        colNum = _this$props$colNum === void 0 ? DefaultProps.colNum : _this$props$colNum;
+    var rows = Math.ceil(data.length / colNum);
+    return rows * lineHeight;
+  };
+
+  _proto.resetScrollTop = function resetScrollTop() {
+    this.setState({
+      currentIndex: 0,
+      scrollTop: 0
+    });
+    setTranslate(this.optionInner, '0px', "0px");
+    this.optionInner.style.marginTop = "0px";
+    this.lastScrollTop = 0;
+  };
+
+  _proto.handleScroll = function handleScroll(_x, y, _max, _bar, _v, h, _pixelX, pixelY) {
+    if (!this.optionInner) return;
+    var scrollHeight = this.getScrollHeight();
+    var _this$props2 = this.props,
+        data = _this$props2.data,
+        _this$props2$itemsInV = _this$props2.itemsInView,
+        itemsInView = _this$props2$itemsInV === void 0 ? DefaultProps.itemsInView : _this$props2$itemsInV,
+        _this$props2$lineHeig = _this$props2.lineHeight,
+        lineHeight = _this$props2$lineHeig === void 0 ? DefaultProps.lineHeight : _this$props2$lineHeig;
+    var fullHeight = itemsInView * lineHeight;
+    var contentHeight = scrollHeight - h;
+    var scrollTop = h > fullHeight ? 0 : y;
+    this.optionInner.style.marginTop = scrollTop * h + "px";
+
+    if (pixelY === undefined || pixelY === 0) {
+      this.lastScrollTop = scrollTop * contentHeight;
+    } else {
+      this.lastScrollTop += pixelY;
+      if (this.lastScrollTop < 0) this.lastScrollTop = 0; // scroll over bottom
+
+      if (this.lastScrollTop > contentHeight) this.lastScrollTop = contentHeight;
+      scrollTop = this.lastScrollTop / contentHeight;
+      this.optionInner.style.marginTop = scrollTop * h + "px";
+    }
+
+    var index = Math.floor(this.lastScrollTop / lineHeight) - 1;
+    if (data.length - itemsInView < index) index = data.length - itemsInView;
+    if (index < 0) index = 0;
+    setTranslate(this.optionInner, '0px', "-" + (this.lastScrollTop + scrollTop * h) + "px");
+    this.setState({
+      scrollTop: scrollTop,
+      currentIndex: index,
+      fixed: h < this.getScrollHeight() ? 'y' : ''
+    });
+  };
+
+  _proto.render = function render() {
+    var _this2 = this;
+
+    var _this$props3 = this.props,
+        className = _this$props3.className,
+        style = _this$props3.style,
+        height = _this$props3.height,
+        _this$props3$lineHeig = _this$props3.lineHeight,
+        lineHeight = _this$props3$lineHeig === void 0 ? DefaultProps.lineHeight : _this$props3$lineHeig,
+        data = _this$props3.data,
+        _this$props3$itemsInV = _this$props3.itemsInView,
+        itemsInView = _this$props3$itemsInV === void 0 ? DefaultProps.itemsInView : _this$props3$itemsInV,
+        renderItem = _this$props3.renderItem,
+        keygen = _this$props3.keygen,
+        _this$props3$colNum = _this$props3.colNum,
+        colNum = _this$props3$colNum === void 0 ? DefaultProps.colNum : _this$props3$colNum;
+    var _this$state = this.state,
+        currentIndex = _this$state.currentIndex,
+        fixed = _this$state.fixed;
+    var scrollHeight = this.getScrollHeight();
+    var ms = Object.assign({}, style, height && {
+      height: height
+    });
+    var items = data.slice(currentIndex * colNum, (currentIndex + itemsInView) * colNum).map(function (d, i) {
+      return React.createElement(Fragment, {
+        key: getKey(d, keygen, i)
+      }, renderItem(d, i));
+    });
+    var fr = Array(colNum).fill('1fr').join(' ');
+    var gridStyle = colNum > 1 ? {
+      display: 'grid',
+      gridTemplateColumns: fr
+    } : {};
+    return React.createElement(Scroll, {
+      stable: true,
+      className: className,
+      style: ms,
+      scroll: fixed,
+      onScroll: this.handleScroll,
+      scrollHeight: scrollHeight,
+      scrollTop: this.state.scrollTop
+    }, React.createElement("div", {
+      ref: function ref(el) {
+        _this2.optionInner = el;
+      },
+      style: gridStyle
+    }, React.createElement("div", {
+      style: {
+        height: currentIndex * lineHeight,
+        gridColumnEnd: '-1'
+      }
+    }), items));
+  };
+
+  return LazyList;
+}(PureComponent);
+
+_defineProperty(LazyList, "defaultProps", DefaultProps);
+
+export default LazyList;

package/esm/AnimationList/List.d.ts

@@ -0,0 +1,10 @@
+import { Component } from 'react';
+import { ListProps } from './Props';
+declare class List extends Component<ListProps> {
+    static displayName: string;
+    static defaultProps: {
+        show: boolean;
+    };
+    render(): JSX.Element;
+}
+export default List;

package/esm/AnimationList/List.js

@@ -0,0 +1,46 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import React, { Component } from 'react';
+import classnames from 'classnames';
+import { listClass } from './styles'; // Use Component cause stateless Element can't use ref
+// eslint-disable-next-line
+
+var List =
+/*#__PURE__*/
+function (_Component) {
+  _inheritsLoose(List, _Component);
+
+  function List() {
+    return _Component.apply(this, arguments) || this;
+  }
+
+  var _proto = List.prototype;
+
+  _proto.render = function render() {
+    var className = classnames(listClass('_'), this.props.className);
+
+    var _this$props = this.props,
+        show = _this$props.show,
+        getRef = _this$props.getRef,
+        props = _objectWithoutPropertiesLoose(_this$props, ["show", "getRef"]);
+
+    return React.createElement("div", _extends({
+      ref: getRef
+    }, props, {
+      className: className,
+      style: this.props.style
+    }));
+  };
+
+  return List;
+}(Component);
+
+_defineProperty(List, "displayName", 'List');
+
+_defineProperty(List, "defaultProps", {
+  show: false
+});
+
+export default List;

package/esm/AnimationList/Props.d.ts

@@ -0,0 +1,61 @@
+import * as React from 'react';
+import { GetScrollContextConsumerValue } from '../Scroll/Props';
+import { GetZIndexConsumerProps } from '../Modal/Props';
+import { ForceAdd, KeygenType, RegularAttributes, StandardProps } from '../@types/common';
+declare type PickerPosition = 'left-bottom' | 'left-top' | 'right-bottom' | 'right-top';
+declare type DropdownPosition = 'bottom-left' | 'bottom-right' | 'top-left' | 'top-right';
+export declare type ListDurationType = 'fast' | 'slow' | number;
+export declare type ListAnimationType = 'collapse' | 'fade' | 'scale-y' | 'scale-x';
+export interface AbsoluteProps {
+    focus?: boolean;
+    fixed?: boolean | 'min';
+    parentElement?: HTMLElement;
+    position?: RegularAttributes.ListPosition | PickerPosition | DropdownPosition;
+    /**
+     * When it is true, the pop-up layer of option append into document.body.
+     *
+     * 为 true 时，选项弹出层在 DOM 中独立 render
+     *
+     * default: false
+     */
+    absolute?: boolean | (() => HTMLElement);
+    scrollElement?: HTMLElement;
+    scrollLeft?: number;
+    scrollTop?: number;
+    rootClass?: string;
+    /**
+     * options z-index
+     *
+     * 选项列表 z-index 值
+     *
+     * default: 1000
+     */
+    zIndex?: number;
+    style?: React.CSSProperties;
+    autoClass?: string;
+    value?: any;
+    getResetPosition?: (resetFunc: () => void) => void;
+    autoAdapt?: boolean;
+}
+declare type GetAbsolutePropsIn<Props> = Omit<ForceAdd<Props, AbsoluteProps>, 'getRef'>;
+export declare type GetAbsoluteProps<Props> = GetZIndexConsumerProps<GetScrollContextConsumerValue<GetAbsolutePropsIn<Props>>>;
+/** -----------List----------* */
+export interface ListProps extends StandardProps {
+    show?: boolean;
+    getRef?: (el: HTMLDivElement) => void;
+    children?: React.ReactNode;
+    onMouseMove?: () => void;
+}
+/** -----------lazyList----------* */
+export interface LazyListProps<DataItem> extends StandardProps {
+    stay?: boolean;
+    data: DataItem[];
+    lineHeight?: number;
+    colNum?: number;
+    itemsInView?: number;
+    height?: number;
+    renderItem: (d: DataItem, i: number) => React.ReactNode;
+    keygen: KeygenType<DataItem>;
+    force?: any;
+}
+export {};

package/esm/AnimationList/Props.js

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

package/esm/AnimationList/index.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { ListDurationType, ListAnimationType } from './Props';
+declare const List: (type: ListAnimationType | ListAnimationType[], duration: ListDurationType, display?: string | undefined) => import("react").ComponentType<import("./Props").ListProps>;
+export default List;