@nutui/nutui-react 0.1.0-beta.1

package/dist/esm/nutui-react.es.js

@@ -0,0 +1,42 @@
+export { default as Avatar } from './Avatar.js';
+export { default as Button } from './Button.js';
+export { default as Cell } from './Cell.js';
+export { default as Icon } from './Icon.js';
+export { default as Price } from './Price.js';
+export { default as Overlay } from './Overlay.js';
+export { default as Divider } from './Divider.js';
+export { default as Layout } from './Layout.js';
+export { default as Drag } from './Drag.js';
+export { default as Collapse } from './Collapse.js';
+export { default as Toast } from './Toast.js';
+export { default as BackTop } from './BackTop.js';
+export { default as Range } from './Range.js';
+export { default as Infiniteloading } from './Infiniteloading.js';
+export { default as Steps } from './Steps.js';
+export { default as Step } from './Step.js';
+export { default as CircleProgress } from './CircleProgress.js';
+export { default as Popup } from './Popup.js';
+export { default as ActionSheet } from './ActionSheet.js';
+export { default as NoticeBar } from './NoticeBar.js';
+export { default as Notify } from './Notify.js';
+export { default as NavBar } from './NavBar.js';
+export { default as Tabbar } from './Tabbar.js';
+export { default as TabbarItem } from './TabbarItem.js';
+export { default as InputNumber } from './InputNumber.js';
+export { default as Elevator } from './Elevator.js';
+export { default as FixedNav } from './FixedNav.js';
+export { default as Pagination } from './Pagination.js';
+export { default as Rate } from './Rate.js';
+export { default as Uploader } from './Uploader.js';
+export { default as Input } from './Input.js';
+export { default as TextArea } from './TextArea.js';
+export { default as Checkbox } from './Checkbox.js';
+export { default as CheckboxGroup } from './CheckboxGroup.js';
+export { default as Tag } from './Tag.js';
+export { default as Badge } from './Badge.js';
+export { default as AnimatingNumbers } from './AnimatingNumbers.js';
+export { default as Radio } from './Radio.js';
+export { default as RadioGroup } from './RadioGroup.js';
+export { default as Signature } from './Signature.js';
+export { default as Barrage } from './Barrage.js';
+export { default as Address } from './Address.js';

package/dist/esm/overlay-418bcf84.js

@@ -0,0 +1,94 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+var _excluded = ["children", "zIndex", "duration", "overlayClass", "closeOnClickOverlay", "visible", "lockScroll", "overlayStyle"];
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+import React__default, { useState, useRef, useEffect } from 'react';
+import { c as cn } from './bem-893ad28d.js';
+import classNames from 'classnames';
+var defaultOverlayProps = {
+  zIndex: 2000,
+  duration: 0.3,
+  overlayClass: '',
+  closeOnClickOverlay: true,
+  visible: false,
+  lockScroll: true,
+  overlayStyle: {}
+};
+
+var Overlay = function Overlay(props) {
+  var _defaultOverlayProps$ = _objectSpread(_objectSpread({}, defaultOverlayProps), props),
+      children = _defaultOverlayProps$.children,
+      zIndex = _defaultOverlayProps$.zIndex,
+      duration = _defaultOverlayProps$.duration,
+      overlayClass = _defaultOverlayProps$.overlayClass,
+      closeOnClickOverlay = _defaultOverlayProps$.closeOnClickOverlay,
+      visible = _defaultOverlayProps$.visible,
+      lockScroll = _defaultOverlayProps$.lockScroll,
+      overlayStyle = _defaultOverlayProps$.overlayStyle,
+      rest = _objectWithoutProperties(_defaultOverlayProps$, _excluded);
+
+  var _useState = useState(visible),
+      _useState2 = _slicedToArray(_useState, 2),
+      show = _useState2[0],
+      setShow = _useState2[1];
+
+  var renderRef = useRef(true);
+  var intervalRef = useRef(0);
+  useEffect(function () {
+    visible && setShow(visible);
+    lock();
+  }, [visible]);
+  useEffect(function () {
+    return function () {
+      clearTimeout(intervalRef.current);
+      document.body.classList.remove('nut-overflow-hidden');
+    };
+  }, []);
+  var b = cn('overlay');
+  var classes = classNames({
+    'overlay-fade-leave-active': !renderRef.current && !visible,
+    'overlay-fade-enter-active': visible,
+    'first-render': renderRef.current && !visible,
+    'hidden-render': !visible
+  }, overlayClass, b(''));
+
+  var styles = _objectSpread({
+    zIndex: zIndex,
+    animationDuration: "".concat(props.duration, "s")
+  }, overlayStyle);
+
+  var lock = function lock() {
+    if (lockScroll && visible) {
+      document.body.classList.add('nut-overflow-hidden');
+    } else {
+      document.body.classList.remove('nut-overflow-hidden');
+    }
+  };
+
+  var handleClick = function handleClick(e) {
+    if (closeOnClickOverlay) {
+      props.onClick && props.onClick(e);
+      renderRef.current = false;
+      var id = setTimeout(function () {
+        setShow(!visible);
+      }, duration * 1000 * 0.8);
+      intervalRef.current = id;
+    }
+  };
+
+  return React__default.createElement(React__default.Fragment, null, React__default.createElement("div", _objectSpread(_objectSpread({
+    className: classes,
+    style: styles
+  }, rest), {}, {
+    onClick: handleClick
+  }), children));
+};
+
+Overlay.defaultProps = defaultOverlayProps;
+Overlay.displayName = 'NutOverlay';
+export { Overlay as O, defaultOverlayProps as d };

package/dist/esm/toast-420b65b7.js

@@ -0,0 +1,294 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+import * as React from 'react';
+import * as ReactDOM from 'react-dom';
+import { c as cn } from './bem-893ad28d.js';
+import { I as Icon } from './icon-63c0d58f.js';
+import classNames from 'classnames';
+
+var Notification = /*#__PURE__*/function (_React$PureComponent) {
+  _inherits(Notification, _React$PureComponent);
+
+  var _super = _createSuper(Notification);
+
+  function Notification(props) {
+    var _this;
+
+    _classCallCheck(this, Notification);
+
+    _this = _super.call(this, props);
+
+    _defineProperty(_assertThisInitialized(_this), "closeTimer", void 0);
+
+    _this.close = _this.close.bind(_assertThisInitialized(_this));
+    _this.startCloseTimer = _this.startCloseTimer.bind(_assertThisInitialized(_this));
+    _this.clearCloseTimer = _this.clearCloseTimer.bind(_assertThisInitialized(_this));
+    _this.close = _this.close.bind(_assertThisInitialized(_this));
+    _this.clickCover = _this.clickCover.bind(_assertThisInitialized(_this));
+    _this.state = {
+      show: true
+    };
+    return _this;
+  }
+
+  _createClass(Notification, [{
+    key: "close",
+    value: function close() {
+      this.setState({
+        show: false
+      });
+      this.clearCloseTimer();
+      this.props.onClose();
+    }
+  }, {
+    key: "startCloseTimer",
+    value: function startCloseTimer() {
+      var _this2 = this;
+
+      var duration = this.props.duration;
+
+      if (duration) {
+        this.closeTimer = window.setTimeout(function () {
+          _this2.close();
+        }, duration * 1000);
+      }
+    }
+  }, {
+    key: "clearCloseTimer",
+    value: function clearCloseTimer() {
+      if (this.closeTimer) {
+        clearTimeout(this.closeTimer);
+        this.closeTimer = -1;
+      }
+    }
+  }, {
+    key: "clickCover",
+    value: function clickCover() {
+      var closeOnClickOverlay = this.props.closeOnClickOverlay;
+
+      if (closeOnClickOverlay) {
+        this.close();
+      }
+    }
+  }, {
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      this.startCloseTimer();
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      this.clearCloseTimer();
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _classNames,
+          _this3 = this;
+
+      var _this$props = this.props,
+          style = _this$props.style,
+          icon = _this$props.icon,
+          msg = _this$props.msg,
+          bottom = _this$props.bottom,
+          center = _this$props.center,
+          bgColor = _this$props.bgColor,
+          coverColor = _this$props.coverColor,
+          textAlignCenter = _this$props.textAlignCenter,
+          size = _this$props.size,
+          customClass = _this$props.customClass,
+          cover = _this$props.cover,
+          type = _this$props.type;
+      this.state;
+      var toastBem = cn('toast');
+      var classes = classNames((_classNames = {}, _defineProperty(_classNames, 'nut-toast-center', center), _defineProperty(_classNames, 'nut-toast-has-icon', icon), _defineProperty(_classNames, 'nut-toast-cover', cover), _defineProperty(_classNames, 'nut-toast-loading', type === 'loading'), _defineProperty(_classNames, "customClass", customClass), _defineProperty(_classNames, 'nut-toast-' + size, true), _classNames));
+      return React.createElement(React.Fragment, null, React.createElement("div", {
+        className: "".concat(toastBem(), " ").concat(classes),
+        style: {
+          bottom: center ? 'auto' : bottom + 'px',
+          backgroundColor: cover ? coverColor : ''
+        },
+        onClick: function onClick() {
+          _this3.clickCover();
+        }
+      }, React.createElement("div", {
+        className: toastBem('inner'),
+        style: {
+          textAlign: textAlignCenter ? 'center' : 'left',
+          backgroundColor: bgColor
+        }
+      }, icon ? React.createElement("p", {
+        className: toastBem('icon-wrapper')
+      }, React.createElement(Icon, {
+        name: icon ? icon : '',
+        size: "20"
+      })) : null, React.createElement("span", {
+        className: toastBem('text')
+      }, msg))));
+    }
+  }]);
+
+  return Notification;
+}(React.PureComponent);
+
+_defineProperty(Notification, "newInstance", void 0);
+
+Notification.newInstance = function (properties, callback) {
+  var element = document.createElement('div');
+
+  if (properties.id) {
+    element.setAttribute('id', "".concat(properties.id));
+  }
+
+  document.body.appendChild(element);
+  var called = false;
+
+  function ref(instance) {
+    if (called) {
+      return;
+    }
+
+    called = true;
+    callback({
+      component: instance,
+      destroy: function destroy() {
+        ReactDOM.unmountComponentAtNode(element);
+        element && element.parentNode && element.parentNode.removeChild(element);
+      }
+    });
+  }
+
+  ReactDOM.render(React.createElement(Notification, _objectSpread(_objectSpread({}, properties), {}, {
+    ref: ref
+  })), element);
+};
+
+var messageInstance = null;
+var options = {
+  msg: '',
+  id: '',
+  duration: 1.5,
+  center: true,
+  type: 'text',
+  customClass: '',
+  bottom: 30,
+  size: 'base',
+  icon: '',
+  textAlignCenter: true,
+  loadingRotate: true,
+  bgColor: 'rgba(0, 0, 0, .8)',
+  onClose: function onClose() {},
+  cover: false,
+  coverColor: 'rgba(0, 0, 0, 0)',
+  closeOnClickOverlay: false // 是否点击遮罩可关闭
+
+};
+
+function getInstance(props, callback) {
+  if (messageInstance) {
+    messageInstance.destroy();
+    messageInstance = null;
+  }
+
+  Notification.newInstance(props, function (notification) {
+    return callback && callback(notification);
+  });
+}
+
+function notice(opts) {
+  function close() {
+    if (messageInstance) {
+      messageInstance.destroy();
+      messageInstance = null;
+    }
+  }
+
+  opts = _objectSpread(_objectSpread(_objectSpread({}, options), opts), {}, {
+    onClose: close
+  });
+  getInstance(opts, function (notification) {
+    messageInstance = notification;
+  });
+}
+
+var errorMsg = function errorMsg(msg) {
+  if (!msg) {
+    console.warn('[NutUI Toast]: msg不能为空');
+    return;
+  }
+};
+
+var Toast = {
+  text: function text(msg) {
+    var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    errorMsg(msg);
+    return notice(_objectSpread({
+      msg: msg,
+      type: 'text'
+    }, option));
+  },
+  success: function success(msg) {
+    var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    errorMsg(msg);
+    return notice(_objectSpread({
+      msg: msg,
+      icon: 'success',
+      type: 'success'
+    }, option));
+  },
+  fail: function fail(msg) {
+    var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    errorMsg(msg);
+    return notice(_objectSpread({
+      msg: msg,
+      icon: 'failure',
+      type: 'fail'
+    }, option));
+  },
+  loading: function loading(msg) {
+    var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    errorMsg(msg);
+    return notice(_objectSpread({
+      msg: msg,
+      icon: 'loading',
+      type: 'loading'
+    }, option));
+  },
+  warn: function warn(msg) {
+    var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    errorMsg(msg);
+    return notice(_objectSpread({
+      msg: msg,
+      icon: 'tips',
+      type: 'warn'
+    }, option));
+  },
+  customIcon: function customIcon(msg) {
+    var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    errorMsg(msg);
+    return notice(_objectSpread({
+      msg: msg
+    }, option));
+  },
+  hide: function hide() {
+    if (messageInstance) {
+      messageInstance.destroy();
+      messageInstance = null;
+    }
+  }
+};
+export { Toast as T };

package/dist/esm/types/src/packages/actionsheet/actionsheet.d.ts

@@ -0,0 +1,20 @@
+import React, { FunctionComponent } from 'react';
+export declare type ItemType<T> = {
+    [key: string]: T;
+};
+export interface ActionSheetProps {
+    cancelTxt: string;
+    optionTag: string;
+    optionSubTag: string;
+    chooseTagValue: string;
+    title: string;
+    color: string;
+    description: string;
+    menuItems: ItemType<string | boolean>[];
+    cancel: () => void;
+    choose: (item: any, index: number) => void;
+    visible: boolean;
+    className: string;
+    style: React.CSSProperties;
+}
+export declare const ActionSheet: FunctionComponent<Partial<ActionSheetProps> & React.HTMLAttributes<HTMLDivElement>>;

package/dist/esm/types/src/packages/actionsheet/index.d.ts

@@ -0,0 +1,2 @@
+import { ActionSheet } from './actionsheet';
+export default ActionSheet;

package/dist/esm/types/src/packages/address/address.d.ts

@@ -0,0 +1,56 @@
+import React, { FunctionComponent, CSSProperties } from 'react';
+export interface RegionData {
+    name?: string;
+    [key: string]: any;
+}
+export interface NextListObj {
+    next: string;
+    value: string | RegionData;
+    custom: string;
+    selectedRegion: {};
+}
+export interface AddressList {
+    id?: string | number;
+    provinceName: string;
+    cityName: string;
+    countyName: string;
+    townName: string;
+    addressDetail: string;
+    selectedAddress: boolean;
+    name?: string;
+    phone?: string;
+}
+export interface CloseRes {
+    data: {};
+    type: string;
+}
+export interface AddressProps {
+    className?: string;
+    style?: CSSProperties;
+    modelValue: boolean;
+    type: string;
+    customAddressTitle: string;
+    province: RegionData[];
+    city: RegionData[];
+    country: RegionData[];
+    town: RegionData[];
+    isShowCustomAddress: Boolean;
+    existAddress: AddressList[];
+    existAddressTitle: string;
+    customAndExistTitle: string;
+    height: string | number;
+    defaultIcon: string;
+    selectedIcon: string;
+    closeBtnIcon: string;
+    backBtnIcon: string;
+    onSelected?: (prevExistAdd: AddressList, item: AddressList, copyExistAdd: AddressList[]) => void;
+    onClose?: (cal: CloseRes) => void;
+    closeMask?: (cal: {
+        closeWay: string;
+    }) => void;
+    switchModule?: (cal: {
+        type: string;
+    }) => void;
+    onChange?: (cal: NextListObj) => void;
+}
+export declare const Address: FunctionComponent<Partial<AddressProps> & Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange'>>;

package/dist/esm/types/src/packages/address/customRender.d.ts

@@ -0,0 +1,18 @@
+import React, { FunctionComponent } from 'react';
+import { RegionData } from './address';
+export interface AddressProps {
+    type: string;
+    province: RegionData[];
+    city: RegionData[];
+    country: RegionData[];
+    town: RegionData[];
+    height: string | number;
+    onNextArea?: (cal: {
+        next: string;
+        value: string | RegionData;
+        custom: string;
+        selectedRegion: {};
+    }) => void;
+    onClose?: () => void;
+}
+export declare const CustomRender: FunctionComponent<Partial<AddressProps> & React.HTMLAttributes<HTMLDivElement>>;

package/dist/esm/types/src/packages/address/existRender.d.ts

@@ -0,0 +1,18 @@
+import React, { FunctionComponent } from 'react';
+import { AddressList } from './address';
+export interface ExistRenderProps {
+    type: string;
+    existAddress: AddressList[] | [];
+    defaultIcon: string;
+    selectedIcon: string;
+    isShowCustomAddress: Boolean;
+    customAndExistTitle: string;
+    onSelected?: (prevExistAdd: AddressList, item: AddressList, copyExistAdd: AddressList[]) => void;
+    onClose?: (cal: {
+        closeWay: string;
+    }) => void;
+    onSwitchModule?: (cal: {
+        type: string;
+    }) => void;
+}
+export declare const ExistRender: FunctionComponent<Partial<ExistRenderProps> & React.HTMLAttributes<HTMLDivElement>>;

package/dist/esm/types/src/packages/address/index.d.ts

@@ -0,0 +1,2 @@
+import { Address } from './address';
+export default Address;

package/dist/esm/types/src/packages/animatingnumbers/animatingnumbers.d.ts

@@ -0,0 +1,12 @@
+import React, { Component } from 'react';
+export interface AnimatingNumbersProps {
+}
+declare type AnimatingNumbersStates = {};
+export declare class AnimatingNumbers extends Component<AnimatingNumbersProps, AnimatingNumbersStates> {
+    static defaultProps: AnimatingNumbersProps;
+    static displayName: string;
+    static CountUp: React.FunctionComponent<Partial<import("./countup").CountUpProps>>;
+    constructor(props: AnimatingNumbersProps);
+    render(): JSX.Element;
+}
+export {};

package/dist/esm/types/src/packages/animatingnumbers/countup.d.ts

@@ -0,0 +1,11 @@
+import React, { FunctionComponent } from 'react';
+export interface CountUpProps {
+    maxLen: number;
+    endNumber: string;
+    delaySpeed?: number;
+    easeSpeed: number;
+    thousands: boolean;
+    className: string;
+    style: React.CSSProperties;
+}
+export declare const CountUp: FunctionComponent<Partial<CountUpProps>>;

package/dist/esm/types/src/packages/animatingnumbers/index.d.ts

@@ -0,0 +1,2 @@
+import { AnimatingNumbers } from './animatingnumbers';
+export default AnimatingNumbers;

package/dist/esm/types/src/packages/avatar/avatar.d.ts

@@ -0,0 +1,14 @@
+import React, { FunctionComponent } from 'react';
+export interface AvatarProps {
+    size: AvatarSize;
+    icon: string;
+    shape: AvatarShape;
+    bgColor: string;
+    prefixCls: string;
+    src: string;
+    className: string;
+    style: React.CSSProperties;
+}
+export declare type AvatarSize = 'large' | 'normal' | 'small';
+export declare type AvatarShape = 'round' | 'square';
+export declare const Avatar: FunctionComponent<Partial<AvatarProps> & React.HTMLAttributes<HTMLDivElement>>;

package/dist/esm/types/src/packages/avatar/index.d.ts

@@ -0,0 +1,2 @@
+import { Avatar } from './avatar';
+export default Avatar;

package/dist/esm/types/src/packages/backtop/backtop.d.ts

@@ -0,0 +1,15 @@
+import { FunctionComponent, CSSProperties } from 'react';
+export interface BackTopProps {
+    className?: string;
+    bottom: number;
+    right: number;
+    elId: string;
+    distance: number;
+    zIndex: number;
+    isAnimation: boolean;
+    duration: number;
+    children?: HTMLElement | any;
+    style?: CSSProperties;
+    backTopClick: (event: MouseEvent) => void;
+}
+export declare const BackTop: FunctionComponent<Partial<BackTopProps>>;

package/dist/esm/types/src/packages/backtop/index.d.ts

@@ -0,0 +1,2 @@
+import { BackTop } from './backtop';
+export default BackTop;

package/dist/esm/types/src/packages/badge/badge.d.ts

@@ -0,0 +1,13 @@
+import { FunctionComponent } from 'react';
+export interface BadgeProps {
+    value: any;
+    dot: boolean;
+    max: Number;
+    top: string;
+    right: string;
+    zIndex: string;
+    color: string;
+    icons: any;
+}
+export declare type BadgeType = 'default' | 'primary' | 'success' | 'warning' | 'danger';
+export declare const Badge: FunctionComponent<Partial<BadgeProps>>;

package/dist/esm/types/src/packages/badge/index.d.ts

@@ -0,0 +1,2 @@
+import { Badge } from './badge';
+export default Badge;

package/dist/esm/types/src/packages/barrage/barrage.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+export interface BarrageProps {
+    className: string;
+    style: React.CSSProperties;
+    barrageList: Array<string>;
+    frequency: number;
+    loop: boolean;
+    speeds: number;
+    rows: number;
+    top: number;
+}
+export declare const Barrage: React.ForwardRefExoticComponent<Partial<BarrageProps> & React.RefAttributes<unknown>>;

package/dist/esm/types/src/packages/barrage/index.d.ts

@@ -0,0 +1,2 @@
+import { Barrage } from './barrage';
+export default Barrage;