@topthink/components 1.0.55 → 1.0.57

package/es/index-4f51cece.js

@@ -0,0 +1,1352 @@
+import Swal from 'sweetalert2/dist/sweetalert2.js';
+import withReactContent from 'sweetalert2-react-content';
+import { jsx, jsxs, Fragment as Fragment$1 } from 'react/jsx-runtime';
+import { useRef, useState, useEffect, createContext, Fragment, useContext, useCallback, useMemo, forwardRef, Children, lazy, Suspense, createElement, useImperativeHandle } from 'react';
+import { OverlayTrigger, Tooltip as Tooltip$1, Spinner, Button as Button$1, Modal as Modal$1, Alert, Card as Card$1, Pagination as Pagination$1 } from 'react-bootstrap';
+import { uniqueId, values, debounce } from 'lodash';
+import axios from 'axios';
+import queryString from 'query-string';
+import * as rax from 'retry-axios';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import Notification from 'rc-notification';
+import styled, { css } from 'styled-components';
+import classNames from 'classnames';
+import { useAsyncCallback } from 'react-async-hook';
+
+const CustomSwal = withReactContent(Swal);
+const defaultOptions$1 = {
+  confirmButtonText: '确定',
+  cancelButtonText: '取消'
+};
+const Message$1 = {
+  confirm: async options => {
+    const {
+      isConfirmed
+    } = await CustomSwal.fire({
+      ...defaultOptions$1,
+      icon: 'warning',
+      showCancelButton: true,
+      ...options,
+      async preConfirm(data) {
+        if (options.preConfirm) {
+          try {
+            return await options.preConfirm(data);
+          } catch (e) {
+            if (e instanceof Error) {
+              CustomSwal.showValidationMessage(e.message);
+            }
+            return false;
+          }
+        }
+        return true;
+      }
+    });
+    return isConfirmed;
+  },
+  success: options => {
+    CustomSwal.fire({
+      ...defaultOptions$1,
+      toast: true,
+      position: 'top',
+      icon: 'success',
+      timer: 2000,
+      showConfirmButton: false,
+      ...options
+    });
+  },
+  error: options => {
+    CustomSwal.fire({
+      ...defaultOptions$1,
+      toast: true,
+      position: 'top',
+      icon: 'error',
+      timer: 5000,
+      showConfirmButton: false,
+      ...options
+    });
+  },
+  close: result => {
+    CustomSwal.close(result);
+  },
+  defaults: defaultOptions$1
+};
+
+function useStateWithCallback(initState) {
+  const callbackRef = useRef(null);
+  const [state, setState] = useState(initState);
+  useEffect(() => {
+    if (callbackRef.current) {
+      callbackRef.current();
+      callbackRef.current = null;
+    }
+  }, [state]);
+  const setCallbackState = (value, callback) => {
+    callbackRef.current = typeof callback === 'function' ? callback : null;
+    setState(value);
+  };
+  return [state, setCallbackState];
+}
+
+const MessageContext = createContext({});
+function wrapMessage(Component) {
+  return _ref => {
+    let {
+      resolve,
+      destroy,
+      message
+    } = _ref;
+    const [show, setShow] = useStateWithCallback(true);
+    const context = useContext(MessageContext);
+    const handleResolve = useCallback(value => {
+      setShow(false, () => {
+        resolve(value);
+      });
+    }, [setShow, resolve]);
+    const state = useMemo(() => {
+      return {
+        show,
+        onHide: () => handleResolve(),
+        onExited: () => destroy(),
+        container: context.container
+      };
+    }, [show, handleResolve, destroy]);
+    return jsx(Component, {
+      resolve: handleResolve,
+      state: state,
+      message: message
+    });
+  };
+}
+function createMessage(Component) {
+  return message => {
+    return new Promise(resolve => {
+      const component = jsx(Component, {
+        resolve: resolve,
+        destroy: () => {
+          hide(component);
+        },
+        message: message
+      });
+      show$1(component);
+    });
+  };
+}
+let listener = () => void 0;
+let memoryState = new Set();
+const show$1 = modal => {
+  memoryState = new Set(memoryState);
+  memoryState.add(modal);
+  listener(memoryState);
+};
+const hide = modal => {
+  memoryState = new Set(memoryState);
+  memoryState.delete(modal);
+  listener(memoryState);
+};
+function Message(props) {
+  const [state, setState] = useState(memoryState);
+  useEffect(() => {
+    listener = setState;
+  }, []);
+  return jsx(MessageContext.Provider, {
+    value: props,
+    children: Array.from(state).map((message, index) => jsx(Fragment, {
+      children: message
+    }, `message-${index}`))
+  });
+}
+
+function show(Component, options) {
+  return createMessage(wrapMessage(Component))(options);
+}
+
+function Tooltip(_ref) {
+  let {
+    tooltip,
+    children,
+    placement = 'bottom'
+  } = _ref;
+  return jsx(OverlayTrigger, {
+    placement: placement,
+    overlay: jsx(Tooltip$1, {
+      id: uniqueId(),
+      children: tooltip
+    }),
+    children: children
+  });
+}
+
+const TableContext = createContext(false);
+
+const Button = forwardRef((_ref, ref) => {
+  let {
+    loading,
+    percent,
+    disabled,
+    children,
+    tooltip,
+    variant,
+    ...props
+  } = _ref;
+  const inTable = useContext(TableContext);
+  if (inTable && !variant) {
+    variant = 'link';
+  }
+  if (loading) {
+    disabled = true;
+    children = jsxs(Fragment$1, {
+      children: [jsx(Spinner, {
+        ref: ref,
+        as: 'span',
+        size: 'sm',
+        role: 'status',
+        "aria-hidden": 'true',
+        animation: 'border'
+      }), percent ? jsxs("span", {
+        className: 'ms-2',
+        children: [percent, "%"]
+      }) : null]
+    });
+  }
+  const button = jsx(Button$1, {
+    ref: ref,
+    ...props,
+    variant: variant,
+    disabled: disabled,
+    children: children
+  });
+  if (tooltip) {
+    return jsx(Tooltip, {
+      tooltip: tooltip,
+      children: jsx("span", {
+        className: 'd-inline-block',
+        children: button
+      })
+    });
+  }
+  return button;
+});
+
+const Confirm = function (_ref) {
+  let {
+    state,
+    message: {
+      title,
+      message,
+      okText,
+      cancelText
+    },
+    resolve
+  } = _ref;
+  return jsxs(Modal$1, {
+    centered: true,
+    ...state,
+    children: [jsx(Modal$1.Header, {
+      children: jsx(Modal$1.Title, {
+        as: 'h5',
+        children: title || '确认'
+      })
+    }), jsx(Modal$1.Body, {
+      children: message
+    }), jsxs(Modal$1.Footer, {
+      children: [jsx(Button, {
+        variant: 'secondary',
+        onClick: () => resolve(),
+        children: cancelText || '取消'
+      }), jsx(Button, {
+        onClick: () => resolve(true),
+        children: okText || '确定'
+      })]
+    })]
+  });
+};
+function confirm(options) {
+  return createMessage(wrapMessage(Confirm))(options);
+}
+
+const Modal = _ref => {
+  let {
+    header,
+    children,
+    footer,
+    closable = true,
+    show,
+    cancelText = '取消',
+    okText = '确定',
+    onOk,
+    onCancel,
+    onHide,
+    okButtonProps,
+    bodyAs,
+    headerAs = 'h5',
+    confirmLoading = false,
+    ...rest
+  } = _ref;
+  const [loading, setLoading] = useState(false);
+  const okButton = useMemo(() => {
+    return jsx(Button, {
+      loading: loading || confirmLoading,
+      variant: 'primary',
+      onClick: async e => {
+        setLoading(true);
+        try {
+          await onOk?.(e);
+          if (!e.defaultPrevented) {
+            onHide?.();
+          }
+        } finally {
+          setLoading(false);
+        }
+      },
+      ...okButtonProps,
+      children: okText
+    });
+  }, [okButtonProps, okText, onOk, onHide, loading, confirmLoading]);
+  const cancelButton = useMemo(() => {
+    return jsx(Button, {
+      variant: 'secondary',
+      onClick: e => {
+        onCancel?.(e);
+        if (!e.defaultPrevented) {
+          onHide?.();
+        }
+      },
+      children: cancelText
+    });
+  }, [onCancel, onHide, cancelText]);
+  switch (typeof footer) {
+    case 'undefined':
+      footer = jsxs(Fragment$1, {
+        children: [cancelButton, okButton]
+      });
+      break;
+    case 'function':
+      footer = footer({
+        okButton,
+        cancelButton
+      });
+      break;
+  }
+  return jsxs(Modal$1, {
+    ...rest,
+    onHide: onHide,
+    show: show,
+    children: [header && jsx(Modal$1.Header, {
+      closeButton: closable,
+      children: jsx(Modal$1.Title, {
+        as: headerAs,
+        children: header
+      })
+    }), jsx(Modal$1.Body, {
+      as: bodyAs,
+      children: children
+    }), footer && jsx(Modal$1.Footer, {
+      children: footer
+    })]
+  });
+};
+Modal.Message = Message;
+Modal.confirm = confirm;
+Modal.show = show;
+
+class Unauthorized extends Error {
+  constructor(url) {
+    super('Unauthorized');
+    _defineProperty(this, "url", void 0);
+    this.url = url;
+  }
+}
+
+let noticeInstance;
+const defaultOptions = {};
+function getNoticeInstance(callback) {
+  if (noticeInstance) {
+    return callback(noticeInstance);
+  }
+  Notification.newInstance({
+    ...defaultOptions,
+    prefixCls: 'notification',
+    maxCount: 5,
+    style: {
+      top: 20,
+      right: 20
+    }
+  }, instance => {
+    if (noticeInstance) {
+      callback(noticeInstance);
+      return;
+    }
+    noticeInstance = instance;
+    callback(instance);
+  });
+}
+const notice = _ref => {
+  let {
+    type,
+    ...options
+  } = _ref;
+  getNoticeInstance(instance => {
+    options.duration = 3;
+    let variant = type;
+    switch (type) {
+      case 'error':
+        variant = 'danger';
+        options.duration = options.closable ? 0 : 5;
+        break;
+    }
+    options.content = jsx(Alert, {
+      variant: variant,
+      children: options.content
+    });
+    instance.notice(options);
+  });
+};
+const types = ['error', 'success', 'info'];
+const Toast = types.reduce((toast, type) => {
+  toast[type] = (content, options) => {
+    notice({
+      ...options,
+      type,
+      content
+    });
+  };
+  return toast;
+}, {});
+Toast.defaults = defaultOptions;
+
+rax.attach();
+axios.defaults.raxConfig = {
+  retryDelay: 2000,
+  backoffType: 'static',
+  shouldRetry: _ref => {
+    let {
+      config,
+      response
+    } = _ref;
+    if (config.raxConfig?.retryDecider && !config.raxConfig.retryDecider()) {
+      return false;
+    }
+    return config.method?.toUpperCase() === 'GET' && response?.status === 449;
+  }
+};
+axios.defaults.maxContentLength = Infinity;
+axios.defaults.maxBodyLength = Infinity;
+axios.defaults.baseURL = '/api';
+axios.defaults.authTokenName = 'authorization';
+axios.interceptors.request.use(config => {
+  const key = config.authTokenName;
+  if (key) {
+    const token = localStorage.getItem(key);
+    if (token) {
+      config.headers = {
+        Authorization: `Bearer ${token}`,
+        ...config.headers
+      };
+    }
+  }
+  return config;
+}, error => {
+  return Promise.reject(error);
+});
+const isRecord = data => {
+  return data && typeof data === 'object';
+};
+axios.interceptors.response.use(response => {
+  if (response.status === 201 && response.data.location) {
+    window.location.href = response.data.location;
+    response.data = undefined; //防止多次跳转
+  }
+
+  return response;
+}, e => {
+  if (axios.isAxiosError(e)) {
+    if (e.response) {
+      const {
+        data,
+        status
+      } = e.response;
+      if (status === 401) {
+        e.errors = 'Unauthorized';
+        if (isRecord(data) && data.url) {
+          e = new Unauthorized(data.url);
+        }
+        Toast.error('Unauthorized');
+      } else {
+        if (isRecord(data)) {
+          if (status === 422) {
+            e.errors = data;
+          } else if ('message' in data) {
+            e.errors = data['message'];
+          }
+        } else {
+          e.errors = data;
+        }
+      }
+    }
+  }
+  return Promise.reject(e);
+});
+const isRequestError = axios.isAxiosError;
+const showRequestError = e => {
+  if (axios.isAxiosError(e)) {
+    let errors = e.errors;
+    if (typeof e.errors !== 'string') {
+      errors = Object.values(e.errors).join('<br />');
+    }
+    Toast.error(errors);
+  } else {
+    throw e;
+  }
+};
+const request = async function (config) {
+  config = typeof config === 'string' ? {
+    url: config
+  } : config;
+  const {
+    data
+  } = await axios.request({
+    paramsSerializer: function (params) {
+      return queryString.stringify(params, {
+        sort: false,
+        skipNull: true,
+        skipEmptyString: true,
+        arrayFormat: 'bracket'
+      });
+    },
+    ...config
+  });
+  return data;
+};
+request.defaults = axios.defaults;
+request.interceptors = axios.interceptors;
+
+const useUnmountedRef = () => {
+  const unmountedRef = useRef(false);
+  useEffect(() => {
+    unmountedRef.current = false;
+    return () => {
+      unmountedRef.current = true;
+    };
+  }, []);
+  return unmountedRef;
+};
+
+function useSafeState(initialState) {
+  const unmountedRef = useUnmountedRef();
+  const [state, setState] = useState(initialState);
+  const setCurrentState = useCallback(currentState => {
+    /** if component is unmounted, stop update */
+    if (unmountedRef.current) return;
+    setState(currentState);
+  }, []);
+  return [state, setCurrentState];
+}
+
+const WaitModal = function (_ref) {
+  let {
+    state,
+    message,
+    resolve
+  } = _ref;
+  const open = useRef(true);
+  const {
+    result,
+    checkUrl,
+    onComplete
+  } = message;
+  const [checking, setChecking] = useSafeState(false);
+  useEffect(() => {
+    request({
+      url: checkUrl,
+      method: 'post',
+      data: {
+        order_no: result.order_no
+      },
+      raxConfig: {
+        shouldRetry(err) {
+          return open.current && err.response?.status === 449;
+        }
+      }
+    }).then(() => {
+      onComplete?.();
+      resolve();
+    }).catch(() => null);
+  }, []);
+  return jsx(Modal, {
+    ...state,
+    centered: true,
+    onHide: () => {
+      open.current = false;
+      state.onHide();
+    },
+    backdrop: 'static',
+    header: '\u652F\u4ED8\u7ED3\u679C',
+    okText: '\u5DF2\u5B8C\u6210\u652F\u4ED8',
+    okButtonProps: {
+      loading: checking
+    },
+    onOk: async e => {
+      e.preventDefault();
+      try {
+        setChecking(true);
+        await request({
+          url: checkUrl,
+          method: 'post',
+          data: {
+            order_no: result.order_no
+          },
+          raxConfig: {
+            shouldRetry() {
+              return false;
+            }
+          }
+        });
+        onComplete?.();
+        resolve();
+      } catch {
+        // ignore
+      } finally {
+        setChecking(false);
+      }
+    },
+    cancelText: '\u53D6\u6D88',
+    children: "\u8BF7\u5728\u65B0\u6253\u5F00\u7684\u9875\u9762\u4E0A\u8FDB\u884C\u652F\u4ED8\uFF0C\u652F\u4ED8\u5B8C\u6210\u540E\u518D\u5173\u95ED\u6B64\u7A97\u53E3"
+  });
+};
+function waitPayComplete(options) {
+  const {
+    result
+  } = options;
+  window.open(result.pay_url);
+  show(WaitModal, options);
+}
+
+const Container$1 = styled.div`
+  padding: 48px 32px;
+`;
+const Icon = styled.div`
+  margin-bottom: 24px;
+  text-align: center;
+  font-size: 72px;
+`;
+const Title$1 = styled.div`
+  color: rgba(0, 0, 0, .85);
+  font-size: 24px;
+  line-height: 1.8;
+  text-align: center;
+`;
+const Extra = styled.div`
+  margin-top: 32px;
+  text-align: center;
+`;
+const IconMap = {
+  success: jsx("i", {
+    className: 'bi bi-check-circle-fill text-success'
+  }),
+  error: jsx("i", {
+    className: 'bi bi-exclamation-circle-fill text-danger'
+  }),
+  info: jsx("i", {
+    className: 'bi bi-info-circle-fill text-info'
+  }),
+  warning: jsx("i", {
+    className: 'bi bi-exclamation-triangle-fill text-warning'
+  })
+};
+function Result(_ref) {
+  let {
+    status,
+    title,
+    icon,
+    extra
+  } = _ref;
+  if (!icon && status) {
+    icon = IconMap[status];
+  }
+  return jsxs(Container$1, {
+    children: [icon && jsx(Icon, {
+      children: icon
+    }), title && jsx(Title$1, {
+      children: title
+    }), extra && jsx(Extra, {
+      children: extra
+    })]
+  });
+}
+
+styled.div`
+  position: relative;
+`;
+const Dimmer = styled.div`
+  display: ${props => props.active ? 'flex' : 'none'};
+  position: absolute;
+  top: 0 !important;
+  left: 0 !important;
+  width: 100%;
+  height: 100%;
+  text-align: center;
+  vertical-align: middle;
+  padding: 1em;
+  background-color: ${props => props.inverted ? 'rgba(255, 255, 255, .85)' : 'rgba(0, 0, 0, .85)'};
+  opacity: ${props => props.active ? 1 : 0};
+  line-height: 1;
+  animation-fill-mode: both;
+  animation-duration: .5s;
+  transition: background-color .5s linear;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  user-select: none;
+  will-change: opacity;
+  z-index: 990;
+`;
+
+function Loader(_ref) {
+  let {
+    loading = true,
+    children,
+    variant = 'primary',
+    animation = 'border',
+    wrap,
+    ...props
+  } = _ref;
+  if (!loading) {
+    return null;
+  }
+  if (children) {
+    children = jsx("p", {
+      className: 'mt-3 text-secondary',
+      children: children
+    });
+  }
+  children = jsxs(Dimmer, {
+    inverted: true,
+    active: true,
+    children: [jsx(Spinner, {
+      animation: animation,
+      variant: variant,
+      ...props
+    }), children]
+  });
+  if (wrap) {
+    return jsx(Wrap, {
+      "$height": typeof wrap === 'number' ? wrap : 150,
+      children: children
+    });
+  }
+  return children;
+}
+const Wrap = styled.div`
+  position: relative;
+  height: ${props => `${props.$height}px`};
+`;
+
+function Card(_ref) {
+  let {
+    children,
+    title,
+    className,
+    ...props
+  } = _ref;
+  return jsx(Card$1, {
+    className: classNames('border-0 shadow-sm mb-3', className),
+    ...props,
+    children: jsxs("div", {
+      className: 'card-body',
+      children: [title && jsxs(Fragment$1, {
+        children: [jsx("h5", {
+          children: title
+        }), jsx("hr", {})]
+      }), children]
+    })
+  });
+}
+
+function Error$1(_ref) {
+  let {
+    errors
+  } = _ref;
+  if (!errors) {
+    return null;
+  }
+  return jsx(Alert, {
+    variant: 'danger',
+    children: jsx("ul", {
+      className: 'mb-0',
+      children: typeof errors === 'string' ? jsx("li", {
+        children: errors
+      }) : Object.entries(errors).map(_ref2 => {
+        let [name, error] = _ref2;
+        return jsx("li", {
+          children: error
+        }, name);
+      })
+    })
+  });
+}
+
+function Space(_ref) {
+  let {
+    children,
+    className,
+    size = 'small',
+    direction = 'horizontal'
+  } = _ref;
+  if (typeof size === 'string') {
+    size = {
+      small: 8,
+      middle: 16,
+      large: 24
+    }[size];
+  }
+  const items = Children.map(children, child => {
+    if (child) {
+      return jsx(Item, {
+        children: child
+      });
+    }
+  });
+  return jsx(Container, {
+    className: className,
+    "$direction": direction,
+    "$size": size,
+    children: items
+  });
+}
+const Container = styled.div`
+  display: inline-flex;
+  align-items: center;
+  gap: ${props => props.$size}px;
+
+  ${props => props.$direction === 'vertical' && css`
+    display: flex;
+    flex-direction: column;
+    align-items: inherit;
+  `}
+`;
+const Item = styled.div`
+
+`;
+
+const LazySteps = lazy(() => import('./steps-afba29a7.js'));
+const LazyStep = lazy(() => import('./steps-afba29a7.js').then(_ref => {
+  let {
+    Step
+  } = _ref;
+  return {
+    default: Step
+  };
+}));
+function Steps(props) {
+  return jsx(Suspense, {
+    fallback: null,
+    children: jsx(LazySteps, {
+      ...props
+    })
+  });
+}
+const Step = function (props) {
+  return jsx(Suspense, {
+    fallback: null,
+    children: jsx(LazyStep, {
+      ...props
+    })
+  });
+};
+Steps.Step = Step;
+
+function Statistic(_ref) {
+  let {
+    title,
+    content,
+    footer
+  } = _ref;
+  return jsxs(Card, {
+    children: [jsx(Title, {
+      children: title
+    }), jsx(Content, {
+      children: content
+    }), footer && jsx(Footer, {
+      children: footer
+    })]
+  });
+}
+const Footer = styled.div`
+  margin-top: 9px;
+  padding-top: 10px;
+  border-top: 1px solid #f0f0f0;
+  color: rgba(0, 0, 0, .65);
+`;
+const Content = styled.div`
+  color: rgba(0, 0, 0, .85);
+  font-size: 24px;
+`;
+const Title = styled.div`
+  margin-bottom: 4px;
+  color: rgba(0, 0, 0, .45);
+  font-size: 1.1rem;
+`;
+
+function noop() {}
+function isInteger(value) {
+  return typeof value === 'number' && isFinite(value) && Math.floor(value) === value;
+}
+function Pagination(_ref) {
+  let {
+    total = 0,
+    onChange = noop,
+    defaultCurrent = 1,
+    defaultPageSize = 10,
+    className,
+    ...props
+  } = _ref;
+  const [current, setCurrent] = useState(defaultCurrent);
+  const [pageSize, setPageSize] = useState(defaultPageSize);
+  useEffect(() => {
+    if (isInteger(props.current)) {
+      setCurrent(props.current);
+    }
+  }, [props.current]);
+  useEffect(() => {
+    if (isInteger(props.pageSize)) {
+      setPageSize(props.pageSize);
+    }
+  }, [props.pageSize]);
+  const allPages = useMemo(() => {
+    return Math.floor((total - 1) / pageSize) + 1;
+  }, [total, pageSize]);
+  const handleChange = useCallback(p => {
+    return () => {
+      if (p !== current) {
+        setCurrent(p);
+        onChange(p, pageSize);
+      }
+    };
+  }, [onChange, current, pageSize]);
+  const pageBufferSize = 2;
+  const prevPage = current - 1 > 0 ? current - 1 : 0;
+  const nextPage = current + 1 < allPages ? current + 1 : allPages;
+  const pagerList = [];
+  let jumpPrev = null;
+  let jumpNext = null;
+  let firstPager = null;
+  let lastPager = null;
+  if (allPages <= 3 + pageBufferSize * 2) {
+    for (let i = 1; i <= allPages; i += 1) {
+      const active = current === i;
+      pagerList.push(jsx(Pagination$1.Item, {
+        active: active,
+        onClick: handleChange(i),
+        children: i
+      }, i));
+    }
+  } else {
+    lastPager = jsx(Pagination$1.Last, {
+      onClick: handleChange(allPages)
+    }, 'last');
+    firstPager = jsx(Pagination$1.First, {
+      onClick: handleChange(1)
+    }, 'first');
+    jumpPrev = jsx(Pagination$1.Prev, {
+      onClick: handleChange(prevPage)
+    }, 'prev');
+    jumpNext = jsx(Pagination$1.Next, {
+      onClick: handleChange(nextPage)
+    }, 'next');
+    let left = Math.max(1, current - pageBufferSize);
+    let right = Math.min(current + pageBufferSize, allPages);
+    if (current - 1 <= pageBufferSize) {
+      right = 1 + pageBufferSize * 2;
+    }
+    if (allPages - current <= pageBufferSize) {
+      left = allPages - pageBufferSize * 2;
+    }
+    for (let i = left; i <= right; i += 1) {
+      const active = current === i;
+      pagerList.push(jsx(Pagination$1.Item, {
+        active: active,
+        onClick: handleChange(i),
+        children: i
+      }, i));
+    }
+    if (current - 1 >= pageBufferSize * 2 && current !== 1 + 2) {
+      pagerList.unshift(jumpPrev);
+    }
+    if (allPages - current >= pageBufferSize * 2 && current !== allPages - 2) {
+      pagerList.push(jumpNext);
+    }
+    if (left !== 1) {
+      pagerList.unshift(firstPager);
+    }
+    if (right !== allPages) {
+      pagerList.push(lastPager);
+    }
+  }
+  return jsx(Pagination$1, {
+    className: className,
+    children: pagerList
+  });
+}
+
+function NumberFormat(_ref) {
+  let {
+    className,
+    value,
+    locale = 'zh-CN',
+    currency = true,
+    options = {}
+  } = _ref;
+  const formatter = useMemo(() => {
+    let opt;
+    if (currency) {
+      opt = {
+        style: 'currency',
+        currency: 'CNY'
+      };
+    } else {
+      opt = {
+        minimumFractionDigits: 2
+      };
+    }
+    return new Intl.NumberFormat(locale, {
+      ...opt,
+      ...options
+    });
+  }, [currency, locale, options]);
+  if (className) {
+    return jsx("span", {
+      className: className,
+      children: formatter.format(value)
+    });
+  }
+  return jsx(Fragment$1, {
+    children: formatter.format(value)
+  });
+}
+
+function LoadingButton(_ref) {
+  let {
+    loading,
+    disabled,
+    children,
+    ...props
+  } = _ref;
+  return jsx(Button$1, {
+    ...props,
+    disabled: loading || disabled,
+    children: loading ? 'Loading…' : children
+  });
+}
+
+const LazyImageZoom = lazy(() => import('./image-zoom-912e2b3b.js'));
+function ImageZoom(props) {
+  return jsx(Suspense, {
+    fallback: null,
+    children: jsx(LazyImageZoom, {
+      ...props
+    })
+  });
+}
+
+function RequestButton(_ref) {
+  let {
+    url,
+    method,
+    confirm,
+    onSuccess,
+    children,
+    disabled,
+    as = Button,
+    ...props
+  } = _ref;
+  const [fetching, setFetching] = useSafeState(false);
+  const handleClick = useCallback(async e => {
+    e.preventDefault();
+    try {
+      setFetching(true);
+      if (confirm) {
+        if (!(await Modal.confirm({
+          message: confirm
+        }))) {
+          return;
+        }
+      }
+      const config = typeof url === 'string' ? {
+        url,
+        method
+      } : {
+        method,
+        ...url
+      };
+      const result = await request(config);
+      if (onSuccess) {
+        onSuccess(result);
+      }
+    } catch (e) {
+      showRequestError(e);
+    } finally {
+      setFetching(false);
+    }
+  }, [url, method, setFetching]);
+  return createElement(as, {
+    ...props,
+    disabled: disabled || fetching,
+    onClick: handleClick
+  }, children);
+}
+
+const LazyForm = lazy(() => import('./form-9c0e638a.js'));
+const Form = forwardRef((props, ref) => {
+  return jsx(Suspense, {
+    fallback: null,
+    children: jsx(LazyForm, {
+      ...props,
+      ref: ref
+    })
+  });
+});
+
+const LazyTable = lazy(() => import('./index-d964165a.js'));
+const Table = forwardRef((props, ref) => {
+  return jsx(Suspense, {
+    fallback: null,
+    children: jsx(LazyTable, {
+      ...props,
+      ref: ref
+    })
+  });
+});
+
+let id = 0;
+function useOverlayState() {
+  let {
+    onHide,
+    onShow
+  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  const [visible, setVisible] = useState(false);
+  const [key, setKey] = useState(`visible-${id}`);
+  const hide = useCallback(() => {
+    setVisible(false);
+    if (onHide) {
+      onHide();
+    }
+  }, [setVisible, onHide]);
+  const exit = useCallback(() => {
+    setKey(`visible-${++id}`);
+  }, [setKey, id]);
+  const show = useCallback(() => {
+    setVisible(true);
+    if (onShow) {
+      onShow();
+    }
+  }, [setVisible, onShow]);
+  const state = {
+    show: visible,
+    onHide: hide,
+    onExited: exit,
+    key
+  };
+  return {
+    visible,
+    show,
+    hide,
+    state
+  };
+}
+
+const ModalButton = forwardRef((_ref, ref) => {
+  let {
+    text,
+    onOk,
+    modalProps,
+    children,
+    onShow,
+    confirmLoading,
+    as = Button,
+    ...props
+  } = _ref;
+  const {
+    state,
+    show,
+    hide
+  } = useOverlayState({
+    onShow
+  });
+  useImperativeHandle(ref, () => ({
+    close: hide
+  }));
+  const handleOk = async e => {
+    if (onOk) {
+      const result = await onOk();
+      if (result === false) {
+        e.preventDefault();
+      }
+    }
+  };
+  const button = createElement(as, {
+    ...props,
+    onClick: show
+  }, text);
+  return jsxs(Fragment$1, {
+    children: [button, jsx(Modal, {
+      header: text,
+      ...modalProps,
+      ...state,
+      confirmLoading: confirmLoading,
+      onOk: handleOk,
+      children: children
+    })]
+  });
+});
+
+function ModalForm(_ref) {
+  let {
+    text,
+    onSuccess,
+    buttonProps,
+    modalProps,
+    children,
+    ...props
+  } = _ref;
+  const [loading, setLoading] = useState(false);
+  const ref = useRef(null);
+  const form = useRef(null);
+  const handleOk = useCallback(() => {
+    form.current?.submit();
+    return false;
+  }, []);
+  const handleSuccess = useCallback(data => {
+    if (onSuccess) {
+      onSuccess(data);
+    }
+    ref.current?.close();
+  }, [onSuccess]);
+  return jsx(ModalButton, {
+    ref: ref,
+    text: text,
+    ...buttonProps,
+    modalProps: modalProps,
+    onOk: handleOk,
+    confirmLoading: loading,
+    children: jsxs(Form, {
+      ...props,
+      onSubmitting: setLoading,
+      ref: form,
+      onSuccess: handleSuccess,
+      children: [children, jsx("input", {
+        type: 'submit',
+        hidden: true
+      })]
+    })
+  });
+}
+
+function useRequest(config) {
+  let {
+    manual,
+    refreshDeps,
+    ...options
+  } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  let {
+    execute,
+    currentParams,
+    error,
+    ...others
+  } = useAsyncCallback(async params => {
+    config = typeof config === 'string' ? {
+      url: config
+    } : config;
+    return await request({
+      ...config,
+      ...params
+    });
+  }, options);
+  useEffect(() => {
+    if (!manual && !refreshDeps) {
+      try {
+        execute();
+      } catch {}
+    }
+  }, []);
+  useEffect(() => {
+    if (refreshDeps) {
+      refresh();
+    }
+  }, refreshDeps);
+  const refresh = useCallback(async () => {
+    try {
+      if (currentParams) {
+        await execute(...currentParams);
+      } else {
+        await execute();
+      }
+    } catch {}
+  }, [execute, currentParams]);
+  if (error && isRequestError(error)) {
+    const errors = error.errors;
+    error = new Error(typeof errors === 'string' ? errors : values(errors).join(''));
+  }
+  return {
+    refresh,
+    execute,
+    error,
+    ...others
+  };
+}
+
+function useCallbackRef(callback) {
+  let deps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  const callbackRef = useRef(callback);
+  useEffect(() => {
+    callbackRef.current = callback;
+  });
+  return useCallback(function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return callbackRef.current?.(...args);
+  }, deps);
+}
+
+function useControllableState(props) {
+  const {
+    value: valueProp,
+    defaultValue,
+    onChange,
+    shouldUpdate = (prev, next) => prev !== next
+  } = props;
+  const onChangeProp = useCallbackRef(onChange);
+  const shouldUpdateProp = useCallbackRef(shouldUpdate);
+  const [uncontrolledState, setUncontrolledState] = useState(defaultValue);
+  const controlled = valueProp !== undefined;
+  const value = controlled ? valueProp : uncontrolledState;
+  const setValue = useCallbackRef(next => {
+    const setter = next;
+    const nextValue = typeof next === 'function' ? setter(value) : next;
+    if (!shouldUpdateProp(value, nextValue)) {
+      return;
+    }
+    if (!controlled) {
+      setUncontrolledState(nextValue);
+    }
+    onChangeProp(nextValue);
+  }, [controlled, onChangeProp, value, shouldUpdateProp]);
+  return [value, setValue];
+}
+
+function useDebounce(callback, wait, options) {
+  const callbackRef = useRef(callback);
+  const debouncedCallbackRef = useRef(debounce(callback, wait, options));
+  useEffect(() => {
+    callbackRef.current = callback;
+  });
+  useEffect(() => {
+    debouncedCallbackRef.current = debounce(function () {
+      callbackRef.current(...arguments);
+    }, wait, options);
+  }, [wait, options]);
+  return debouncedCallbackRef.current;
+}
+
+export { Button as B, Card as C, Error$1 as E, Form as F, ImageZoom as I, Loader as L, Message$1 as M, NumberFormat as N, Pagination as P, Result as R, Space as S, TableContext as T, Unauthorized as U, useDebounce as a, useControllableState as b, Toast as c, Steps as d, Step as e, Statistic as f, LoadingButton as g, RequestButton as h, Table as i, ModalForm as j, ModalButton as k, Modal as l, Tooltip as m, useRequest as n, useOverlayState as o, isRequestError as p, request as r, showRequestError as s, useSafeState as u, waitPayComplete as w };
+//# sourceMappingURL=index-4f51cece.js.map