• Version 1.26.35
  • Published
  • 34 MB
  • 15 dependencies
  • MIT license


npm i @alifd/next
yarn add @alifd/next
pnpm add @alifd/next


A configurable component library for web built on React.




class Affix

class Affix extends React.Component<AffixProps, any> {}

    class Animate

    class Animate extends React.Component<AnimateProps, any> {}

      class Avatar

      class Avatar extends React.Component<AvatarProps, any> {}

        class Badge

        class Badge extends React.Component<BadgeProps, any> {}

          class Balloon

          class Balloon extends React.Component<BalloonProps, any> {}

            property Tooltip

            static Tooltip: typeof Tooltip;

              class Box

              class Box extends Component<BoxProps, any> {}
                class Breadcrumb extends React.Component<BreadcrumbProps, any> {}
                  static Item: typeof Item;

                    class Button

                    class Button extends React.Component<ButtonProps, any> {}

                      property Group

                      static Group: typeof Group;

                        class Calendar

                        class Calendar extends React.Component<CalendarProps, any> {}

                          class Calendar2

                          class Calendar extends React.Component<CalendarProps, any> {}

                            class Card

                            class Card extends React.Component<CardProps, any> {}

                              property Actions

                              static Actions: React.ComponentType<CardActionsProps>;

                                property BulletHeader

                                static BulletHeader: React.ComponentType<CardBulletHeaderProps>;

                                  property CollapseContent

                                  static CollapseContent: React.ComponentType<CardCollapseContentProps>;

                                    property CollaspeContent

                                    static CollaspeContent: React.ComponentType<CardCollaspeContentProps>;

                                      property Content

                                      static Content: React.ComponentType<CardContentProps>;

                                        property Divider

                                        static Divider: React.ComponentType<CardDividerProps>;

                                          property Header

                                          static Header: React.ComponentType<CardHeaderProps>;

                                            property Media

                                            static Media: React.ComponentType<CardMediaProps>;

                                              class Cascader

                                              class Cascader extends React.Component<CascaderProps, any> {}

                                                class CascaderSelect

                                                class CascaderSelect extends React.Component<CascaderSelectProps, any> {}

                                                  class Checkbox

                                                  class Checkbox extends React.Component<CheckboxProps, any> {}

                                                    property Group

                                                    static Group: typeof Group;

                                                      class Collapse

                                                      class Collapse extends React.Component<CollapseProps, any> {}

                                                        property Panel

                                                        static Panel: typeof Panel;

                                                          class ConfigProvider

                                                          class ConfigProvider extends React.Component<ConfigProviderProps, any> {}

                                                            method clearCache

                                                            static clearCache: () => any;

                                                              method config

                                                              static config: (Component: any, options?: any) => any;

                                                                method Consumer

                                                                static Consumer: (props: {
                                                                children: (ctx: ConfigProviderProps) => React.ReactNode;
                                                                }) => JSX.Element;

                                                                  method getContextProps

                                                                  static getContextProps: (props: {}, displayName: string) => any;

                                                                    method getDirection

                                                                    static getDirection: () => string;

                                                                      method getLanguage

                                                                      static getLanguage: () => string;

                                                                        method getLocale

                                                                        static getLocale: () => any;

                                                                          method initLocales

                                                                          static initLocales: (locales: any) => any;

                                                                            method setDirection

                                                                            static setDirection: (dir: string) => any;

                                                                              method setLanguage

                                                                              static setLanguage: (language: string) => any;

                                                                                method setLocale

                                                                                static setLocale: (locale: any) => any;

                                                                                  class DatePicker

                                                                                  class DatePicker extends React.Component<DatePickerProps, any> {}

                                                                                    property MonthPicker

                                                                                    static MonthPicker: typeof MonthPicker;

                                                                                      property RangePicker

                                                                                      static RangePicker: typeof RangePicker;

                                                                                        property WeekPicker

                                                                                        static WeekPicker: React.ComponentType<DatePickerProps>;

                                                                                          property YearPicker

                                                                                          static YearPicker: typeof YearPicker;

                                                                                            class DatePicker2

                                                                                            class DatePicker extends React.Component<DatePickerProps, any> {}

                                                                                              property MonthPicker

                                                                                              static MonthPicker: typeof MonthPicker;

                                                                                                property QuarterPicker

                                                                                                static QuarterPicker: typeof QuarterPicker;

                                                                                                  property RangePicker

                                                                                                  static RangePicker: typeof RangePicker;

                                                                                                    property WeekPicker

                                                                                                    static WeekPicker: typeof WeekPicker;

                                                                                                      property YearPicker

                                                                                                      static YearPicker: typeof YearPicker;

                                                                                                        class Dialog

                                                                                                        class Dialog extends React.Component<DialogProps, any> {}

                                                                                                          method alert

                                                                                                          static alert: (config: QuickShowConfig) => QuickShowRet;

                                                                                                            method confirm

                                                                                                            static confirm: (config: QuickShowConfig) => QuickShowRet;

                                                                                                              method error

                                                                                                              static error: (config: QuickShowConfig) => QuickShowRet;

                                                                                                                method help

                                                                                                                static help: (config: QuickShowConfig) => QuickShowRet;

                                                                                                                  method notice

                                                                                                                  static notice: (config: QuickShowConfig) => QuickShowRet;

                                                                                                                    method show

                                                                                                                    static show: (config: QuickShowConfig) => QuickShowRet;

                                                                                                                      method success

                                                                                                                      static success: (config: QuickShowConfig) => QuickShowRet;

                                                                                                                        method warning

                                                                                                                        static warning: (config: QuickShowConfig) => QuickShowRet;

                                                                                                                          class Divider

                                                                                                                          class Divider extends React.Component<DividerProps, any> {}

                                                                                                                            class Drawer

                                                                                                                            class Drawer extends React.Component<DrawerProps, any> {}

                                                                                                                              method show

                                                                                                                              static show: (config: DrawerProps) => QuickShowRet;
                                                                                                                                class Dropdown extends React.Component<DropdownProps, any> {}

                                                                                                                                  class Field

                                                                                                                                  class Field extends innerField {}


                                                                                                                                    constructor(contextComp: any, options?: FieldOption);
                                                                                                                                    • Parameter contextComp


                                                                                                                                      Parameter options


                                                                                                                                    method useField

                                                                                                                                    static useField: (options?: FieldOption) => Field;
                                                                                                                                    • react hooks 风格使用 Field

                                                                                                                                      Parameter options

                                                                                                                                    method validate

                                                                                                                                    validate: {
                                                                                                                                    (callback?: (errors: object[], values: object) => void): void;
                                                                                                                                    names?: string | string[],
                                                                                                                                    callback?: (errors: object[], values: object) => void
                                                                                                                                    ): void;
                                                                                                                                    • 校验

                                                                                                                                      Parameter callback

                                                                                                                                    • 校验

                                                                                                                                      Parameter names

                                                                                                                                      Parameter callback

                                                                                                                                    class Form

                                                                                                                                    class Form extends React.Component<FormProps, any> {}

                                                                                                                                      property Error

                                                                                                                                      static Error: typeof Error;

                                                                                                                                        property Item

                                                                                                                                        static Item: typeof Item;

                                                                                                                                          property Reset

                                                                                                                                          static Reset: typeof Reset;

                                                                                                                                            property Submit

                                                                                                                                            static Submit: typeof Submit;

                                                                                                                                              class Grid

                                                                                                                                              class Grid extends React.Component<GridProps, any> {}

                                                                                                                                                property Col

                                                                                                                                                static Col: typeof Col;

                                                                                                                                                  property Row

                                                                                                                                                  static Row: typeof Row;

                                                                                                                                                    class Icon

                                                                                                                                                    class Icon extends React.Component<IconProps, any> {}

                                                                                                                                                      method createFromIconfontCN

                                                                                                                                                      static createFromIconfontCN: (options: iconOptions) => typeof CustomIcon;

                                                                                                                                                        class Input

                                                                                                                                                        class Input extends React.Component<InputProps, any> {}

                                                                                                                                                          property getInputNode

                                                                                                                                                          getInputNode: () => HTMLInputElement;

                                                                                                                                                            property Group

                                                                                                                                                            static Group: typeof Group;

                                                                                                                                                              property Password

                                                                                                                                                              static Password: typeof Password;

                                                                                                                                                                property TextArea

                                                                                                                                                                static TextArea: typeof TextArea;

                                                                                                                                                                  class List

                                                                                                                                                                  class List extends Component<ListProps, any> {}

                                                                                                                                                                    property Item

                                                                                                                                                                    static Item: ComponentType<ListItemProps>;

                                                                                                                                                                      class Loading

                                                                                                                                                                      class Loading extends React.Component<LoadingProps, any> {}
                                                                                                                                                                        class Menu extends React.Component<MenuProps, any> {}
                                                                                                                                                                          static CheckboxItem: typeof CheckboxItem;
                                                                                                                                                                            static Divider: typeof Divider;
                                                                                                                                                                              static Group: typeof Group;
                                                                                                                                                                                static Item: typeof Item;
                                                                                                                                                                                  static PopupItem: typeof PopupItem;
                                                                                                                                                                                    static RadioItem: typeof RadioItem;
                                                                                                                                                                                      static SubMenu: typeof SubMenu;
                                                                                                                                                                                        static create: (props: any) => void;
                                                                                                                                                                                          class MenuButton extends React.Component<MenuButtonProps, any> {}
                                                                                                                                                                                            static Divider: typeof Divider;
                                                                                                                                                                                              static Group: typeof Group;
                                                                                                                                                                                                static Item: typeof Item;

                                                                                                                                                                                                  class Message

                                                                                                                                                                                                  class Message extends React.Component<MessageProps, any> {}

                                                                                                                                                                                                    method config

                                                                                                                                                                                                    static config: (props: OpenProps) => void;

                                                                                                                                                                                                      method error

                                                                                                                                                                                                      static error: (props: OpenProps) => void;

                                                                                                                                                                                                        method help

                                                                                                                                                                                                        static help: (props: OpenProps) => void;

                                                                                                                                                                                                          method hide

                                                                                                                                                                                                          static hide: () => void;

                                                                                                                                                                                                            method loading

                                                                                                                                                                                                            static loading: (props: OpenProps) => void;

                                                                                                                                                                                                              method notice

                                                                                                                                                                                                              static notice: (props: OpenProps) => void;

                                                                                                                                                                                                                method show

                                                                                                                                                                                                                static show: (props: OpenProps) => void;

                                                                                                                                                                                                                  method success

                                                                                                                                                                                                                  static success: (props: OpenProps) => void;

                                                                                                                                                                                                                    method warning

                                                                                                                                                                                                                    static warning: (props: OpenProps) => void;
                                                                                                                                                                                                                      class Nav extends React.Component<NavProps, any> {}
                                                                                                                                                                                                                        static Group: typeof Group;
                                                                                                                                                                                                                          static Item: typeof Item;
                                                                                                                                                                                                                            static PopupItem: typeof PopupItem;
                                                                                                                                                                                                                              static SubNav: typeof SubNav;

                                                                                                                                                                                                                                class Notification

                                                                                                                                                                                                                                class Notification {}

                                                                                                                                                                                                                                  property close

                                                                                                                                                                                                                                  static close: (key: string) => void;

                                                                                                                                                                                                                                    property config

                                                                                                                                                                                                                                    static config: (config: NotificationConfig) => NotificationConfig;

                                                                                                                                                                                                                                      property destroy

                                                                                                                                                                                                                                      static destroy: () => void;

                                                                                                                                                                                                                                        property error

                                                                                                                                                                                                                                        static error: (options: NotificationOptions) => string;

                                                                                                                                                                                                                                          property help

                                                                                                                                                                                                                                          static help: (options: NotificationOptions) => string;

                                                                                                                                                                                                                                            property notice

                                                                                                                                                                                                                                            static notice: (options: NotificationOptions) => string;

                                                                                                                                                                                                                                              property open

                                                                                                                                                                                                                                              static open: (options: NotificationOptions) => string;

                                                                                                                                                                                                                                                property success

                                                                                                                                                                                                                                                static success: (options: NotificationOptions) => string;

                                                                                                                                                                                                                                                  property warning

                                                                                                                                                                                                                                                  static warning: (options: NotificationOptions) => string;

                                                                                                                                                                                                                                                    class NumberPicker

                                                                                                                                                                                                                                                    class NumberPicker extends React.Component<NumberPickerProps, any> {}

                                                                                                                                                                                                                                                      property getInputNode

                                                                                                                                                                                                                                                      getInputNode: () => Input;

                                                                                                                                                                                                                                                        class Overlay

                                                                                                                                                                                                                                                        class Overlay extends React.Component<OverlayProps, any> {}

                                                                                                                                                                                                                                                          property Popup

                                                                                                                                                                                                                                                          static Popup: typeof Popup;

                                                                                                                                                                                                                                                            class Pagination

                                                                                                                                                                                                                                                            class Pagination extends React.Component<PaginationProps, any> {}

                                                                                                                                                                                                                                                              class Paragraph

                                                                                                                                                                                                                                                              class Paragraph extends React.Component<ParagraphProps, any> {}

                                                                                                                                                                                                                                                                class Progress

                                                                                                                                                                                                                                                                class Progress extends React.Component<ProgressProps, any> {}

                                                                                                                                                                                                                                                                  class Radio

                                                                                                                                                                                                                                                                  class Radio extends React.Component<RadioProps, any> {}

                                                                                                                                                                                                                                                                    property Group

                                                                                                                                                                                                                                                                    static Group: typeof Group;

                                                                                                                                                                                                                                                                      class Range

                                                                                                                                                                                                                                                                      class Range extends React.Component<RangeProps, any> {}

                                                                                                                                                                                                                                                                        class Rating

                                                                                                                                                                                                                                                                        class Rating extends React.Component<RatingProps, any> {}

                                                                                                                                                                                                                                                                          class ResponsiveGrid

                                                                                                                                                                                                                                                                          class ResponsiveGrid extends Component<ResponsiveGridProps, any> {}

                                                                                                                                                                                                                                                                            property Cell

                                                                                                                                                                                                                                                                            static Cell: typeof Cell;
                                                                                                                                                                                                                                                                              class Search extends React.Component<SearchProps, any> {}

                                                                                                                                                                                                                                                                                class Select

                                                                                                                                                                                                                                                                                class Select extends React.Component<SelectProps, any> {}

                                                                                                                                                                                                                                                                                  property AutoComplete

                                                                                                                                                                                                                                                                                  static AutoComplete: typeof AutoComplete;

                                                                                                                                                                                                                                                                                    property Option

                                                                                                                                                                                                                                                                                    static Option: typeof Option;

                                                                                                                                                                                                                                                                                      property OptionGroup

                                                                                                                                                                                                                                                                                      static OptionGroup: typeof OptionGroup;

                                                                                                                                                                                                                                                                                        class Shell

                                                                                                                                                                                                                                                                                        class Shell extends Component<ShellProps, any> {}

                                                                                                                                                                                                                                                                                          property Action

                                                                                                                                                                                                                                                                                          static Action: ComponentType<ShellCommonProps>;

                                                                                                                                                                                                                                                                                            property Ancillary

                                                                                                                                                                                                                                                                                            static Ancillary: ComponentType<ShellAncillaryProps>;

                                                                                                                                                                                                                                                                                              property AppBar

                                                                                                                                                                                                                                                                                              static AppBar: ComponentType<ShellCommonProps>;

                                                                                                                                                                                                                                                                                                property Branding

                                                                                                                                                                                                                                                                                                static Branding: ComponentType<ShellCommonProps>;

                                                                                                                                                                                                                                                                                                  property Content

                                                                                                                                                                                                                                                                                                  static Content: ComponentType<ShellCommonProps>;

                                                                                                                                                                                                                                                                                                    property Footer

                                                                                                                                                                                                                                                                                                    static Footer: ComponentType<ShellCommonProps>;

                                                                                                                                                                                                                                                                                                      property LocalNavigation

                                                                                                                                                                                                                                                                                                      static LocalNavigation: ComponentType<ShellLocalNavigationProps>;

                                                                                                                                                                                                                                                                                                        property MultiTask

                                                                                                                                                                                                                                                                                                        static MultiTask: ComponentType<ShellCommonProps>;

                                                                                                                                                                                                                                                                                                          property Navigation

                                                                                                                                                                                                                                                                                                          static Navigation: ComponentType<ShellNavigationProps>;

                                                                                                                                                                                                                                                                                                            property ToolDock

                                                                                                                                                                                                                                                                                                            static ToolDock: ComponentType<ShellToolDockProps>;

                                                                                                                                                                                                                                                                                                              property ToolDockItem

                                                                                                                                                                                                                                                                                                              static ToolDockItem: ComponentType<ShellCommonProps>;

                                                                                                                                                                                                                                                                                                                class Slider

                                                                                                                                                                                                                                                                                                                class Slider extends React.Component<SliderProps, any> {}

                                                                                                                                                                                                                                                                                                                  class SplitButton

                                                                                                                                                                                                                                                                                                                  class SplitButton extends React.Component<SplitButtonProps, any> {}

                                                                                                                                                                                                                                                                                                                    property Divider

                                                                                                                                                                                                                                                                                                                    static Divider: typeof Divider;

                                                                                                                                                                                                                                                                                                                      property Group

                                                                                                                                                                                                                                                                                                                      static Group: typeof Group;

                                                                                                                                                                                                                                                                                                                        property Item

                                                                                                                                                                                                                                                                                                                        static Item: typeof Item;

                                                                                                                                                                                                                                                                                                                          class Step

                                                                                                                                                                                                                                                                                                                          class Step extends React.Component<StepProps, any> {}

                                                                                                                                                                                                                                                                                                                            property Item

                                                                                                                                                                                                                                                                                                                            static Item: typeof Item;

                                                                                                                                                                                                                                                                                                                              class Switch

                                                                                                                                                                                                                                                                                                                              class Switch extends React.Component<SwitchProps, any> {}

                                                                                                                                                                                                                                                                                                                                class Tab

                                                                                                                                                                                                                                                                                                                                class Tab extends React.Component<TabProps, any> {}

                                                                                                                                                                                                                                                                                                                                  property Item

                                                                                                                                                                                                                                                                                                                                  static Item: typeof Item;

                                                                                                                                                                                                                                                                                                                                    class Table

                                                                                                                                                                                                                                                                                                                                    class Table extends React.Component<TableProps, any> {}

                                                                                                                                                                                                                                                                                                                                      property Base

                                                                                                                                                                                                                                                                                                                                      static Base: typeof Table;

                                                                                                                                                                                                                                                                                                                                        property Column

                                                                                                                                                                                                                                                                                                                                        static Column: typeof Column;

                                                                                                                                                                                                                                                                                                                                          property ColumnGroup

                                                                                                                                                                                                                                                                                                                                          static ColumnGroup: typeof ColumnGroup;

                                                                                                                                                                                                                                                                                                                                            property GroupFooter

                                                                                                                                                                                                                                                                                                                                            static GroupFooter: typeof GroupFooter;

                                                                                                                                                                                                                                                                                                                                              property GroupHeader

                                                                                                                                                                                                                                                                                                                                              static GroupHeader: typeof GroupHeader;

                                                                                                                                                                                                                                                                                                                                                property StickyLock

                                                                                                                                                                                                                                                                                                                                                static StickyLock: typeof Table;

                                                                                                                                                                                                                                                                                                                                                  class Tag

                                                                                                                                                                                                                                                                                                                                                  class Tag extends React.Component<TagProps, any> {}

                                                                                                                                                                                                                                                                                                                                                    property Closeable

                                                                                                                                                                                                                                                                                                                                                    static Closeable: typeof Closeable;

                                                                                                                                                                                                                                                                                                                                                      property Group

                                                                                                                                                                                                                                                                                                                                                      static Group: typeof TagGroup;

                                                                                                                                                                                                                                                                                                                                                        property Selectable

                                                                                                                                                                                                                                                                                                                                                        static Selectable: typeof Selectable;

                                                                                                                                                                                                                                                                                                                                                          class Timeline

                                                                                                                                                                                                                                                                                                                                                          class Timeline extends React.Component<TimelineProps, any> {}

                                                                                                                                                                                                                                                                                                                                                            property Item

                                                                                                                                                                                                                                                                                                                                                            static Item: typeof Item;

                                                                                                                                                                                                                                                                                                                                                              class TimePicker

                                                                                                                                                                                                                                                                                                                                                              class TimePicker extends React.Component<TimePickerProps, any> {}

                                                                                                                                                                                                                                                                                                                                                                class TimePicker2

                                                                                                                                                                                                                                                                                                                                                                class TimePicker extends React.Component<TimePickerProps, any> {}

                                                                                                                                                                                                                                                                                                                                                                  property RangePicker

                                                                                                                                                                                                                                                                                                                                                                  static RangePicker: typeof RangePicker;

                                                                                                                                                                                                                                                                                                                                                                    class Transfer

                                                                                                                                                                                                                                                                                                                                                                    class Transfer extends React.Component<TransferProps, any> {}

                                                                                                                                                                                                                                                                                                                                                                      class Tree

                                                                                                                                                                                                                                                                                                                                                                      class Tree extends React.Component<TreeProps, any> {}

                                                                                                                                                                                                                                                                                                                                                                        property Node

                                                                                                                                                                                                                                                                                                                                                                        static Node: typeof Node;

                                                                                                                                                                                                                                                                                                                                                                          class TreeSelect

                                                                                                                                                                                                                                                                                                                                                                          class TreeSelect extends React.Component<TreeSelectProps, any> {}

                                                                                                                                                                                                                                                                                                                                                                            class Typography

                                                                                                                                                                                                                                                                                                                                                                            class Typography extends Component<TypographyProps, any> {}

                                                                                                                                                                                                                                                                                                                                                                              property H1

                                                                                                                                                                                                                                                                                                                                                                              static H1: ComponentType<TitleProps>;

                                                                                                                                                                                                                                                                                                                                                                                property H2

                                                                                                                                                                                                                                                                                                                                                                                static H2: ComponentType<TitleProps>;

                                                                                                                                                                                                                                                                                                                                                                                  property H3

                                                                                                                                                                                                                                                                                                                                                                                  static H3: ComponentType<TitleProps>;

                                                                                                                                                                                                                                                                                                                                                                                    property H4

                                                                                                                                                                                                                                                                                                                                                                                    static H4: ComponentType<TitleProps>;

                                                                                                                                                                                                                                                                                                                                                                                      property H5

                                                                                                                                                                                                                                                                                                                                                                                      static H5: ComponentType<TitleProps>;

                                                                                                                                                                                                                                                                                                                                                                                        property H6

                                                                                                                                                                                                                                                                                                                                                                                        static H6: ComponentType<TitleProps>;

                                                                                                                                                                                                                                                                                                                                                                                          property Paragraph

                                                                                                                                                                                                                                                                                                                                                                                          static Paragraph: ComponentType<ParagraphProps>;

                                                                                                                                                                                                                                                                                                                                                                                            property Text

                                                                                                                                                                                                                                                                                                                                                                                            static Text: ComponentType<TextProps>;

                                                                                                                                                                                                                                                                                                                                                                                              class Upload

                                                                                                                                                                                                                                                                                                                                                                                              class Upload extends React.Component<UploadProps, any> {}

                                                                                                                                                                                                                                                                                                                                                                                                property abort

                                                                                                                                                                                                                                                                                                                                                                                                abort: (file: File) => void;
                                                                                                                                                                                                                                                                                                                                                                                                • 中断某个文件上传

                                                                                                                                                                                                                                                                                                                                                                                                  Parameter file


                                                                                                                                                                                                                                                                                                                                                                                                property Card

                                                                                                                                                                                                                                                                                                                                                                                                static Card: typeof Card;

                                                                                                                                                                                                                                                                                                                                                                                                  property Dragger

                                                                                                                                                                                                                                                                                                                                                                                                  static Dragger: typeof Dragger;

                                                                                                                                                                                                                                                                                                                                                                                                    property ErrorCode

                                                                                                                                                                                                                                                                                                                                                                                                    static ErrorCode: typeof ErrorCode;

                                                                                                                                                                                                                                                                                                                                                                                                      property isUploading

                                                                                                                                                                                                                                                                                                                                                                                                      isUploading: () => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                      • 上传状态

                                                                                                                                                                                                                                                                                                                                                                                                      property replaceFiles

                                                                                                                                                                                                                                                                                                                                                                                                      replaceFiles: (old: object, current: object) => void;
                                                                                                                                                                                                                                                                                                                                                                                                      • 替换文件

                                                                                                                                                                                                                                                                                                                                                                                                      property Selecter

                                                                                                                                                                                                                                                                                                                                                                                                      static Selecter: typeof Selecter;

                                                                                                                                                                                                                                                                                                                                                                                                        property selectFiles

                                                                                                                                                                                                                                                                                                                                                                                                        selectFiles: (file: File) => void;
                                                                                                                                                                                                                                                                                                                                                                                                        • 添加文件

                                                                                                                                                                                                                                                                                                                                                                                                          Parameter files

                                                                                                                                                                                                                                                                                                                                                                                                        property startUpload

                                                                                                                                                                                                                                                                                                                                                                                                        startUpload: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                        • 控制文件上传

                                                                                                                                                                                                                                                                                                                                                                                                        property Uploader

                                                                                                                                                                                                                                                                                                                                                                                                        static Uploader: typeof Uploader;

                                                                                                                                                                                                                                                                                                                                                                                                          property uploadFiles

                                                                                                                                                                                                                                                                                                                                                                                                          uploadFiles: (file: File) => void;
                                                                                                                                                                                                                                                                                                                                                                                                          • 控制文件上传

                                                                                                                                                                                                                                                                                                                                                                                                            Parameter file


                                                                                                                                                                                                                                                                                                                                                                                                          class VirtualList

                                                                                                                                                                                                                                                                                                                                                                                                          class VirtualList extends React.Component<VirtualListProps, any> {}

                                                                                                                                                                                                                                                                                                                                                                                                            Package Files (63)

                                                                                                                                                                                                                                                                                                                                                                                                            Dependencies (15)

                                                                                                                                                                                                                                                                                                                                                                                                            Dev Dependencies (133)

                                                                                                                                                                                                                                                                                                                                                                                                            Peer Dependencies (4)


                                                                                                                                                                                                                                                                                                                                                                                                            To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                            You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@alifd/next.

                                                                                                                                                                                                                                                                                                                                                                                                            • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                            • HTML
                                                                                                                                                                                                                                                                                                                                                                                                              <a href="https://www.jsdocs.io/package/@alifd/next"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>