@alifd/next

  • Version 1.25.36
  • Published
  • 33.8 MB
  • 14 dependencies
  • MIT license

Install

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

Overview

A configurable component library for web built on React.

Index

Classes

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> {}
                                                                                                                              class Dropdown extends React.Component<DropdownProps, any> {}

                                                                                                                                class Field

                                                                                                                                class Field extends innerField {}

                                                                                                                                  constructor

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

                                                                                                                                    传入调用class的this

                                                                                                                                    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 Card

                                                                                                                                                                                                                                                                                                                                                                                              static Card: typeof Card;

                                                                                                                                                                                                                                                                                                                                                                                                property Dragger

                                                                                                                                                                                                                                                                                                                                                                                                static Dragger: typeof Dragger;

                                                                                                                                                                                                                                                                                                                                                                                                  property Selecter

                                                                                                                                                                                                                                                                                                                                                                                                  static Selecter: typeof Selecter;

                                                                                                                                                                                                                                                                                                                                                                                                    property Uploader

                                                                                                                                                                                                                                                                                                                                                                                                    static Uploader: typeof Uploader;

                                                                                                                                                                                                                                                                                                                                                                                                      class VirtualList

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

                                                                                                                                                                                                                                                                                                                                                                                                        Package Files (63)

                                                                                                                                                                                                                                                                                                                                                                                                        Dependencies (14)

                                                                                                                                                                                                                                                                                                                                                                                                        Dev Dependencies (130)

                                                                                                                                                                                                                                                                                                                                                                                                        Peer Dependencies (4)

                                                                                                                                                                                                                                                                                                                                                                                                        Badge

                                                                                                                                                                                                                                                                                                                                                                                                        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
                                                                                                                                                                                                                                                                                                                                                                                                          [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@alifd/next)
                                                                                                                                                                                                                                                                                                                                                                                                        • 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>