sinking-antd 1.0.0

package/dist/index.mjs

@@ -0,0 +1,2037 @@
+import React, { createContext, useContext, useMemo, useState, useEffect, useCallback, forwardRef, useImperativeHandle, useRef } from 'react';
+import * as AntdIcons from '@ant-design/icons';
+import { createFromIconfontCN, MenuUnfoldOutlined, MenuFoldOutlined, DownOutlined, UpOutlined, RedoOutlined, QuestionCircleOutlined } from '@ant-design/icons';
+import { createStyles, useResponsive, useTheme as useTheme$1, ThemeProvider } from 'antd-style';
+import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
+import { Breadcrumb, App, Spin, Layout, Space, ConfigProvider, Menu, Drawer, Button, Form, Col, Row, Tag, Switch, Rate, Progress, Typography, Card, Affix, Pagination, Table, Modal as Modal$1, Watermark, Select, Input, InputNumber, TimePicker, DatePicker, Tooltip, theme } from 'antd';
+import 'dayjs/locale/zh-cn';
+import dayjs from 'dayjs';
+
+// src/icon/index.tsx
+var globalIconfontUrl = void 0;
+var setIconfontUrl = (url) => {
+  globalIconfontUrl = url;
+  iconfontCache = null;
+};
+var getIconfontUrl = () => {
+  return globalIconfontUrl;
+};
+var IconFontContext = createContext({});
+var IconFontProvider = ({ iconfontUrl, children }) => {
+  return /* @__PURE__ */ jsx(IconFontContext.Provider, { value: { iconfontUrl }, children });
+};
+var useStyles = createStyles(() => ({
+  iconWrapper: {
+    display: "inline-flex",
+    alignItems: "center",
+    justifyContent: "center"
+  }
+}));
+var Icon = React.forwardRef(
+  ({ type, iconfontUrl, className, style, onClick, ...rest }, ref) => {
+    const { styles, cx } = useStyles();
+    const context = useContext(IconFontContext);
+    const currentIconfontUrl = iconfontUrl || context.iconfontUrl || globalIconfontUrl;
+    const IconfontIcon = useMemo(() => {
+      if (!currentIconfontUrl) {
+        return null;
+      }
+      return createFromIconfontCN({
+        scriptUrl: currentIconfontUrl
+      });
+    }, [currentIconfontUrl]);
+    const AntdIconComponent = AntdIcons[type];
+    if (AntdIconComponent) {
+      return /* @__PURE__ */ jsx(
+        AntdIconComponent,
+        {
+          ref,
+          className: cx(styles.iconWrapper, className),
+          style,
+          onClick,
+          ...rest
+        }
+      );
+    }
+    if (type.startsWith("icon-")) {
+      if (!IconfontIcon) {
+        return /* @__PURE__ */ jsx("span", { ref, className: cx(styles.iconWrapper, className), style, onClick, ...rest, children: type });
+      }
+      return /* @__PURE__ */ jsx(
+        IconfontIcon,
+        {
+          type,
+          ref,
+          className: cx(styles.iconWrapper, className),
+          style,
+          onClick,
+          ...rest
+        }
+      );
+    }
+    return /* @__PURE__ */ jsx("span", { ref, className: cx(styles.iconWrapper, className), style, onClick, ...rest, children: type });
+  }
+);
+var getAntdIconNames = () => {
+  return Object.keys(AntdIcons).filter((key) => {
+    return !key.startsWith("create") && !key.startsWith("set") && !key.startsWith("get") && key !== "default";
+  });
+};
+var iconfontCache = null;
+var normalizeUrl = (url) => {
+  if (url.startsWith("//")) {
+    return `https:${url}`;
+  }
+  if (url.startsWith("http://") || url.startsWith("https://")) {
+    return url;
+  }
+  return url.startsWith("/") ? url : `/${url}`;
+};
+var getIconfontIconNames = async (url) => {
+  const targetUrl = url || globalIconfontUrl;
+  if (!targetUrl) {
+    return [];
+  }
+  if (url && iconfontCache) {
+    iconfontCache = null;
+  }
+  if (iconfontCache) return iconfontCache;
+  try {
+    const urls = Array.isArray(targetUrl) ? targetUrl : [targetUrl];
+    const iconSets = await Promise.all(
+      urls.map(async (scriptUrl) => {
+        try {
+          const response = await fetch(normalizeUrl(scriptUrl));
+          const scriptText = await response.text();
+          return [...scriptText.matchAll(/id="(icon-[^"]+)"/g)].map((m) => m[1]);
+        } catch (_) {
+          return [];
+        }
+      })
+    );
+    const allIcons = [...new Set(iconSets.flat())];
+    iconfontCache = allIcons;
+    return allIcons;
+  } catch (_) {
+    return [];
+  }
+};
+var getAllIconNames = async (iconfontUrl) => {
+  const [antdIcons, iconfontIcons] = await Promise.all([
+    Promise.resolve(getAntdIconNames()),
+    getIconfontIconNames(iconfontUrl)
+  ]);
+  return [...antdIcons, ...iconfontIcons];
+};
+var useBreadCrumbStyles = createStyles(({ token }) => {
+  return {
+    bread: {
+      backgroundColor: token?.colorBgContainer,
+      padding: "5px 15px 5px 15px",
+      fontSize: "12px"
+    },
+    breadStyle: {
+      color: "rgb(156, 156, 156)",
+      cursor: "pointer"
+    }
+  };
+});
+var BreadCrumb = React.memo((props) => {
+  const {
+    style,
+    className,
+    enabled = true,
+    items = [],
+    hideBreadCrumb = false
+  } = props;
+  const { styles: { bread, breadStyle } } = useBreadCrumbStyles();
+  if (!enabled || hideBreadCrumb || items.length === 0) {
+    return null;
+  }
+  const breadCrumbData = items.map((item) => ({
+    title: item.title,
+    onClick: item.onClick,
+    className: breadStyle
+  }));
+  return /* @__PURE__ */ jsx(
+    Breadcrumb,
+    {
+      className: `${bread} ${className || ""}`,
+      style,
+      items: breadCrumbData
+    }
+  );
+});
+var breadcrumb_default = BreadCrumb;
+var Message;
+var Notification;
+var Modal;
+var antd_default = () => {
+  const staticFunction = App.useApp();
+  Message = staticFunction.message;
+  Modal = staticFunction.modal;
+  Notification = staticFunction.notification;
+  return null;
+};
+var getDefaultTheme = (color, radius) => {
+  return {
+    token: {
+      colorPrimary: color,
+      colorInfo: color,
+      borderRadius: radius
+    }
+  };
+};
+var getCompactTheme = (color, radius) => {
+  let temp = getDefaultTheme(color, radius);
+  temp.algorithm = [theme.compactAlgorithm];
+  return temp;
+};
+var getMode = () => {
+  const mode = localStorage?.getItem("theme");
+  if (mode == "light" || mode == "dark") {
+    return mode;
+  }
+  return "auto";
+};
+var setModeToStorage = (mode) => {
+  localStorage?.setItem("theme", mode);
+};
+var ThemeContext = createContext(void 0);
+var useTheme = () => {
+  const context = useContext(ThemeContext);
+  if (!context) {
+    return void 0;
+  }
+  return context;
+};
+var Theme = ({
+  children,
+  theme: customTheme,
+  mode: customMode,
+  appearance: customAppearance,
+  onAppearanceChange
+}) => {
+  const existingContext = useContext(ThemeContext);
+  if (existingContext && !customTheme && !customMode && !customAppearance && !onAppearanceChange) {
+    return children;
+  }
+  return /* @__PURE__ */ jsx(
+    ThemeProviderInner,
+    {
+      theme: customTheme,
+      mode: customMode,
+      appearance: customAppearance,
+      onAppearanceChange,
+      children
+    }
+  );
+};
+var ThemeProviderInner = ({
+  children,
+  theme: customTheme,
+  mode: customMode,
+  appearance: customAppearance,
+  onAppearanceChange
+}) => {
+  const [themes, setThemes] = useState(customTheme || getDefaultTheme("#1890ff", 6));
+  const [mode, setMode2] = useState(customMode || getMode());
+  const [appearance, setAppearance] = useState(customAppearance !== void 0 ? customAppearance : null);
+  const lightMode = "light";
+  const darkMode = "dark";
+  const autoMode = "auto";
+  const setDefaultTheme = () => {
+    setThemes(getDefaultTheme(themes?.token?.colorPrimary, themes?.token?.borderRadius));
+  };
+  const setCompactTheme = () => {
+    setThemes(getCompactTheme(themes?.token?.colorPrimary, themes?.token?.borderRadius));
+  };
+  const setColor = (color) => {
+    let temp = { ...themes };
+    temp.token.colorPrimary = color;
+    temp.token.colorInfo = color;
+    setThemes(temp);
+  };
+  const setRadius = (radius) => {
+    let temp = { ...themes };
+    temp.token.borderRadius = radius;
+    setThemes(temp);
+  };
+  const getModeName = (modeValue) => {
+    if (modeValue == lightMode) {
+      return "\u4EAE\u8272\u98CE\u683C";
+    }
+    if (modeValue == darkMode) {
+      return "\u6697\u8272\u98CE\u683C";
+    }
+    return "\u8DDF\u968F\u7CFB\u7EDF";
+  };
+  const setLightMode = () => {
+    setModeToStorage(lightMode);
+    setMode2(lightMode);
+    setAppearance(lightMode);
+  };
+  const setDarkMode = () => {
+    setModeToStorage(darkMode);
+    setMode2(darkMode);
+    setAppearance(darkMode);
+  };
+  const setAutoMode = () => {
+    setModeToStorage(autoMode);
+    setMode2(autoMode);
+    setAppearance(null);
+  };
+  const isLightMode = () => {
+    return mode == lightMode;
+  };
+  const isDarkMode = () => {
+    return mode == darkMode;
+  };
+  const isAutoMode = () => {
+    return mode == autoMode;
+  };
+  const isLightTheme = () => {
+    return appearance == lightMode;
+  };
+  const isDarkTheme = () => {
+    return appearance == darkMode;
+  };
+  const isCompactTheme = () => {
+    return themes?.algorithm && Array.isArray(themes.algorithm) && themes.algorithm.includes(theme.compactAlgorithm);
+  };
+  const toggle = () => {
+    if (isAutoMode()) {
+      setLightMode();
+    } else if (isLightMode()) {
+      setDarkMode();
+    } else {
+      setAutoMode();
+    }
+  };
+  const value = {
+    themes,
+    setColor,
+    setRadius,
+    setThemes,
+    setDefaultTheme,
+    setCompactTheme,
+    appearance,
+    setAppearance,
+    mode,
+    getModeName,
+    lightMode,
+    darkMode,
+    autoMode,
+    setLightMode,
+    setDarkMode,
+    setAutoMode,
+    isLightMode,
+    isDarkMode,
+    isAutoMode,
+    isLightTheme,
+    isDarkTheme,
+    isCompactTheme,
+    toggle
+  };
+  return /* @__PURE__ */ jsx(ThemeContext.Provider, { value, children: /* @__PURE__ */ jsxs(
+    ThemeProvider,
+    {
+      theme: themes,
+      themeMode: mode,
+      appearance,
+      onAppearanceChange: (newAppearance) => {
+        onAppearanceChange?.(newAppearance);
+        setAppearance(newAppearance);
+      },
+      children: [
+        /* @__PURE__ */ jsx(antd_default, {}),
+        children
+      ]
+    }
+  ) });
+};
+var theme_default = Theme;
+var Animate = {
+  None: "",
+  FadeUp: "fadeInUp",
+  FadeDown: "fadeInDown"
+};
+var useStyles2 = createStyles(({ css }) => ({
+  fadeInUp: css`
+        @keyframes fadeInUp {
+            0% {
+                opacity: 0;
+                transform: translateY(20px);
+            }
+            100% {
+                opacity: 1;
+                transform: translateY(0);
+            }
+        }
+        animation-name: fadeInUp;
+        animation-duration: 0.5s;
+    `,
+  fadeInDown: css`
+        @keyframes fadeInDown {
+            0% {
+                opacity: 0;
+                transform: translateY(-20px);
+            }
+            100% {
+                opacity: 1;
+                transform: translateY(0);
+            }
+        }
+        animation-name: fadeInDown;
+        animation-duration: 0.5s;
+    `
+}));
+var Animation = React.memo(({ animate, style, children }) => {
+  const { styles } = useStyles2();
+  const animationClass = useMemo(() => {
+    return animate && animate !== Animate.None ? styles?.[animate] : null;
+  }, [animate, styles]);
+  return /* @__PURE__ */ jsx("div", { className: animationClass, style, children });
+});
+var animation_default = Animation;
+var Title = ({ ...props }) => {
+  const {
+    placement = "left",
+    size = "normal",
+    open = true,
+    width = 5,
+    height = 0,
+    radius = -1,
+    space = 7
+  } = props;
+  const theme2 = useTheme();
+  const getHeight = (h, s) => {
+    if (h > 0) {
+      return h;
+    }
+    const sizeMap = {
+      small: 15,
+      normal: 20,
+      larger: 25
+    };
+    return sizeMap[s] || 20;
+  };
+  const useStyles7 = createStyles(({ token }) => {
+    const isCompact = theme2?.isCompactTheme() || false;
+    const barRadius = radius < 0 ? token?.borderRadius > 3 ? token?.borderRadius : 0 : radius;
+    const barHeight = isCompact ? getHeight(height, size) - 5 : barRadius > 0 ? getHeight(height, size) : getHeight(height, size) - 3;
+    const barWidth = isCompact || !isCompact && barRadius <= 0 ? width - 1 : width;
+    return {
+      center: {
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "start"
+      },
+      leftBar: {
+        width: barWidth,
+        height: barHeight,
+        borderTopRightRadius: barRadius,
+        borderBottomRightRadius: barRadius,
+        marginRight: space,
+        backgroundColor: token?.colorPrimary
+      },
+      rightBar: {
+        width: barWidth,
+        height: barHeight,
+        borderTopLeftRadius: barRadius,
+        borderBottomLeftRadius: barRadius,
+        marginLeft: space,
+        backgroundColor: token?.colorPrimary
+      }
+    };
+  });
+  const { styles: { center, leftBar, rightBar } } = useStyles7();
+  const left = /* @__PURE__ */ jsxs("div", { className: center, children: [
+    open && /* @__PURE__ */ jsx("span", { className: leftBar }),
+    props?.children
+  ] });
+  const right = /* @__PURE__ */ jsxs("div", { className: center, children: [
+    props?.children,
+    open && /* @__PURE__ */ jsx("span", { className: rightBar })
+  ] });
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    placement == "left" && left,
+    placement == "right" && right
+  ] });
+};
+var title_default = Title;
+var useStyles3 = createStyles(({ css }) => {
+  return {
+    body: css`
+            padding: 10px;
+        `,
+    load: {
+      margin: "0 auto",
+      width: "100%",
+      lineHeight: "80vh"
+    },
+    gutter: {
+      display: "flex"
+    }
+  };
+});
+var Body = React.memo((props) => {
+  const {
+    children,
+    loading,
+    style,
+    className,
+    space = true,
+    animation = true
+  } = props;
+  const { styles: { body, load, gutter }, cx } = useStyles3();
+  return /* @__PURE__ */ jsx(App, { children: loading ? /* @__PURE__ */ jsx(Spin, { spinning: true, size: "large", className: load }) : /* @__PURE__ */ jsx(Layout, { style, children: /* @__PURE__ */ jsx("div", { className: cx("ant-layout-body", className || body), children: /* @__PURE__ */ jsx(animation_default, { animate: animation ? Animate.FadeUp : Animate.None, children: space ? /* @__PURE__ */ jsx(Space, { direction: "vertical", size: "middle", className: gutter, children }) : children }) }) }) });
+});
+var body_default = Body;
+var Footer = React.memo(({ children }) => {
+  return /* @__PURE__ */ jsx(Fragment, { children });
+});
+var footer_default = Footer;
+var useStyles4 = createStyles(({ css }) => {
+  return {
+    box: {
+      display: "flex",
+      alignItems: "center",
+      justifyContent: "space-between"
+    },
+    right: css`
+            z-index: 2;
+        `,
+    left: css`
+            z-index: 2;
+        `
+  };
+});
+var Header = React.memo((props) => {
+  const { styles: { box, right, left } } = useStyles4();
+  return /* @__PURE__ */ jsxs("div", { className: box, children: [
+    props?.left && /* @__PURE__ */ jsx("div", { className: left, children: props.left }),
+    props?.right && /* @__PURE__ */ jsx("div", { className: right, children: props.right })
+  ] });
+});
+var header_default = Header;
+var useStyles5 = createStyles(({ token, isDarkMode }) => {
+  return {
+    left: {
+      position: "relative",
+      background: token?.colorBgContainer,
+      height: "100%",
+      display: "flex",
+      flexDirection: "column"
+    },
+    content: {
+      flex: 1,
+      overflowY: "auto"
+    },
+    menu: {
+      zIndex: 1,
+      overflow: "auto",
+      overflowX: "hidden",
+      borderRight: "none !important",
+      fontWeight: "600",
+      userSelect: "none",
+      ":focus-visible": {
+        outline: "none !important"
+      },
+      "::-webkit-scrollbar": {
+        width: 0
+      },
+      ".ant-menu-item-selected::after": {
+        borderRadius: (token?.borderRadius || 0) > 3 ? `${token.borderRadius}px 0 0 ${token.borderRadius}px` : "0",
+        borderRightWidth: "4px !important",
+        ...token?.borderRadius > 3 && {
+          right: "5px !important",
+          top: "19% !important",
+          height: "60% !important"
+        }
+      },
+      ".ant-menu-item,.ant-menu-submenu-title": {
+        transition: "border-color 0.3s,background 0.3s !important"
+      }
+    },
+    menuTop: {
+      zIndex: 2,
+      userSelect: "none",
+      height: "100px",
+      lineHeight: "100px !important",
+      width: "100%",
+      padding: "10px !important",
+      overflow: "hidden",
+      cursor: "pointer",
+      display: "flex",
+      justifyContent: "center",
+      alignItems: "center",
+      background: token?.colorBgContainer + " !important"
+    },
+    menuBottom: {
+      background: token?.colorBgContainer,
+      userSelect: "none",
+      padding: "0px !important",
+      borderRadius: "0px",
+      height: "50px",
+      lineHeight: "50px !important",
+      borderTop: "0.5px solid " + token?.colorBorder + " !important",
+      borderBottom: "0.5px solid " + token?.colorBorder + " !important",
+      fontWeight: "bolder",
+      fontSize: 14,
+      color: isDarkMode ? "rgb(255,255,255,0.65)" : "rgba(122,122,122)",
+      cursor: "pointer",
+      overflow: "hidden",
+      width: "100%",
+      zIndex: 2,
+      transition: "background 0.3s !important",
+      display: "flex",
+      justifyContent: "center",
+      alignItems: "center"
+    },
+    logoClose: {
+      margin: "0px -10px"
+    },
+    menu2: {
+      fontWeight: "bolder",
+      userSelect: "none",
+      fontSize: "13px",
+      flex: "auto",
+      height: "55px",
+      borderBottom: "none !important"
+    },
+    darkColor: {
+      background: "#001529 !important",
+      backgroundColor: "#001529 !important"
+    },
+    darkBorderTop: {
+      borderTop: "0.5px solid #202020 !important",
+      color: "white"
+    }
+  };
+});
+var Sider = React.memo((props) => {
+  const {
+    collapsed,
+    pathname,
+    matchedRoutes = [],
+    onNavigate,
+    onMenuClick,
+    menus,
+    onLogoClick,
+    collapsedLogo,
+    unCollapsedLogo,
+    menuBottomBtnIcon = null,
+    menuBottomBtnText = null,
+    onMenuBottomBtnClick,
+    classNames,
+    layout = "inline",
+    theme: theme2 = "light"
+  } = props;
+  const { mobile } = useResponsive();
+  const token = useTheme$1();
+  const { styles: { left, content, menu, menuTop, menuBottom, menu2, darkColor, darkBorderTop }, cx } = useStyles5();
+  const [selectedKeys, setSelectedKeys] = useState([]);
+  const [stateOpenKeys, setStateOpenKeys] = useState([]);
+  useEffect(() => {
+    if (pathname) {
+      setSelectedKeys([pathname]);
+      setStateOpenKeys(matchedRoutes);
+    }
+  }, [pathname, matchedRoutes]);
+  const levelKeys = useMemo(() => {
+    const key = {};
+    const func = (items2, level = 1) => {
+      items2.forEach((item) => {
+        if (item?.key) {
+          key[item.key] = level;
+        }
+        if (item?.children) {
+          return func(item.children, level + 1);
+        }
+      });
+    };
+    func(menus);
+    return key;
+  }, [menus]);
+  const onOpenChange = useCallback((openKeys) => {
+    const currentOpenKey = openKeys.find((key) => stateOpenKeys.indexOf(key) === -1);
+    if (currentOpenKey !== void 0) {
+      const repeatIndex = openKeys.filter((key) => key !== currentOpenKey).findIndex((key) => levelKeys[key] === levelKeys[currentOpenKey]);
+      setStateOpenKeys(
+        openKeys.filter((_, index) => index !== repeatIndex).filter((key) => levelKeys[key] <= levelKeys[currentOpenKey])
+      );
+    } else {
+      setStateOpenKeys(openKeys);
+    }
+  }, [stateOpenKeys, levelKeys]);
+  const menuTheme = useMemo(() => {
+    if (token?.isDarkMode) return "light";
+    return theme2 === "dark" ? theme2 : "light";
+  }, [token?.isDarkMode, theme2]);
+  const getColor = useMemo(() => {
+    return !token?.isDarkMode && menuTheme === "dark" ? " " + darkColor : "";
+  }, [token?.isDarkMode, menuTheme, darkColor]);
+  const getBorderColor = useMemo(() => {
+    return !token?.isDarkMode && menuTheme === "dark" ? " " + darkBorderTop : "";
+  }, [token?.isDarkMode, menuTheme, darkBorderTop]);
+  const menuConfig = useMemo(() => ({
+    components: {
+      Menu: {
+        itemSelectedColor: token?.colorPrimaryText || "",
+        itemColor: token?.colorTextSecondary || "",
+        itemHoverColor: token?.colorTextSecondary || "",
+        fontSize: 13,
+        itemMarginBlock: 0,
+        itemMarginInline: 0,
+        itemBorderRadius: 0,
+        subMenuItemBorderRadius: 0,
+        activeBarWidth: 4,
+        itemHeight: 45,
+        subMenuItemBg: "rgba(255, 255, 255, 0)"
+      }
+    }
+  }), [token?.colorPrimaryText, token?.colorTextSecondary]);
+  const handleMenuClick = useCallback((item) => {
+    if (onNavigate) {
+      onNavigate(item?.key);
+    }
+    setSelectedKeys([item?.key]);
+    onMenuClick?.(item);
+  }, [onNavigate, onMenuClick]);
+  const handleLogoClick = useCallback(() => {
+    onLogoClick?.();
+  }, [onLogoClick]);
+  return /* @__PURE__ */ jsx(Fragment, { children: layout === "inline" ? /* @__PURE__ */ jsxs(Layout, { className: cx(left, getColor), children: [
+    /* @__PURE__ */ jsxs(Layout.Header, { className: cx(menuTop, getColor), onClick: handleLogoClick, children: [
+      (mobile || !mobile && !collapsed) && unCollapsedLogo?.(!token?.isDarkMode),
+      !mobile && collapsed && collapsedLogo?.(token?.isDarkMode)
+    ] }),
+    /* @__PURE__ */ jsx(Layout.Content, { className: cx(content, getColor), children: /* @__PURE__ */ jsx(ConfigProvider, { theme: menuConfig, children: /* @__PURE__ */ jsx(
+      Menu,
+      {
+        selectedKeys,
+        theme: menuTheme,
+        mode: "inline",
+        items: menus,
+        className: cx(menu, classNames),
+        openKeys: !collapsed ? stateOpenKeys : void 0,
+        onOpenChange,
+        onClick: handleMenuClick
+      }
+    ) }) }),
+    (menuBottomBtnIcon || menuBottomBtnText) && /* @__PURE__ */ jsxs(
+      Layout.Footer,
+      {
+        className: cx(menuBottom, getColor, getBorderColor),
+        onClick: onMenuBottomBtnClick,
+        children: [
+          menuBottomBtnIcon && (typeof menuBottomBtnIcon === "string" ? /* @__PURE__ */ jsx(Icon, { type: menuBottomBtnIcon }) : menuBottomBtnIcon),
+          (mobile || !mobile && !collapsed) && menuBottomBtnText
+        ]
+      }
+    )
+  ] }) : /* @__PURE__ */ jsx(ConfigProvider, { theme: menuConfig, children: /* @__PURE__ */ jsx(
+    Menu,
+    {
+      theme: menuTheme,
+      mode: "horizontal",
+      selectedKeys,
+      items: menus,
+      className: cx(menu2, classNames),
+      onClick: handleMenuClick
+    }
+  ) }) });
+});
+var sider_default = Sider;
+var useLoadingStyles = createStyles(() => {
+  return {
+    body: {
+      width: "100%",
+      margin: "0 auto",
+      lineHeight: "80vh"
+    }
+  };
+});
+var Loading = () => {
+  const { styles: { body } } = useLoadingStyles();
+  return /* @__PURE__ */ jsx(Spin, { size: "large", className: body });
+};
+var useLayoutStyles = createStyles(({ isDarkMode, token, css, responsive }) => {
+  return {
+    container: {
+      display: "flex",
+      flexDirection: "row"
+    },
+    sider: {
+      zIndex: 2,
+      boxShadow: "2px 0 8px 0 rgba(29,35,41,.05)",
+      background: "none !important",
+      height: "100vh",
+      overflowY: "auto",
+      position: "sticky",
+      left: 0,
+      top: 0,
+      bottom: 0,
+      transition: "all 0.3s,background 0s,height 0s",
+      ".ant-layout-header": {
+        backgroundColor: token?.colorBgContainer
+      }
+    },
+    menuBtn: {
+      width: "55px !important",
+      height: "55px",
+      lineHeight: "55px",
+      fontSize: "15px !important",
+      cursor: "pointer",
+      float: "left",
+      ":hover": {
+        background: "none !important"
+      }
+    },
+    drawMenu: {
+      padding: "0px !important"
+    },
+    body: css`
+            transition: margin-left 0.3s !important;
+            background-color: ${isDarkMode ? "black" : "transparent"};
+            display: flex;
+            flex-direction: column;
+            min-height: 100vh;
+        `,
+    sticky: {
+      position: "sticky",
+      top: 0,
+      left: 0
+    },
+    header: css`
+            padding: 0;
+            height: 55px;
+            line-height: 55px;
+            width: 100%;
+            z-index: 3;
+            box-shadow: 0 2px 8px 0 ${isDarkMode ? "rgba(0, 0, 0, 0.25)" : "rgba(29, 35, 41, 0.05)"};
+            user-select: none;
+            background: ${token?.colorBgContainer} !important;
+            flex-shrink: 0;
+
+            .ant-menu-item-icon {
+                color: ${isDarkMode ? "rgb(255,255,255,0.85)" : ""};
+            }
+        `,
+    horizontalContent: css`
+            width: 100%;
+            flex: 1 0 auto;
+        `,
+    inlineContent: css`
+            width: 100%;
+            flex: 1 0 auto;
+        `,
+    flowContent: css`
+            .ant-layout-body {
+                width: 80%;
+                margin-left: 10%;
+            }
+
+            ${responsive.md} {
+                .ant-layout-body {
+                    width: 100%;
+                    margin-left: 0;
+                }
+            }
+        `,
+    footer: css`
+            text-align: center;
+            flex-shrink: 0;
+        `,
+    flow: {
+      display: "flex",
+      justifyContent: "space-between",
+      height: "55px"
+    },
+    logo: {
+      display: "inline-flex",
+      justifyContent: "center",
+      alignItems: "center",
+      width: "220px",
+      height: "55px"
+    },
+    darkColor: {
+      backgroundColor: "#001529 !important"
+    },
+    layoutNormal: css`
+            min-height: 100vh;
+            display: flex;
+            flex-direction: column;
+        `
+  };
+});
+var SinKing = forwardRef((props, ref) => {
+  let {
+    loading = false,
+    breadCrumb = true,
+    breadCrumbItems = [],
+    hideBreadCrumb = false,
+    menus,
+    menuClassNames,
+    pathname,
+    matchedRoutes,
+    onNavigate,
+    onMenuClick,
+    onMenuBtnClick,
+    onLogoClick,
+    collapsedLogo,
+    unCollapsedLogo,
+    headerRight,
+    headerLeft,
+    headerFixed,
+    headerHidden = false,
+    menuCollapsedWidth = 60,
+    menuUnCollapsedWidth = 220,
+    menuBottomBtnIcon = void 0,
+    menuBottomBtnText = void 0,
+    onMenuBottomBtnClick,
+    layout = "inline",
+    flowLayout = false,
+    menuTheme = "light",
+    waterMark = void 0,
+    children
+  } = props;
+  const systemTheme = useTheme$1();
+  const [collapsed, setCollapsed] = useState(false);
+  const [open, setOpen] = useState(false);
+  const {
+    styles: {
+      container,
+      sider,
+      inlineContent,
+      sticky,
+      header,
+      horizontalContent,
+      footer,
+      body,
+      drawMenu,
+      menuBtn,
+      flow,
+      logo,
+      darkColor,
+      flowContent,
+      layoutNormal
+    },
+    cx
+  } = useLayoutStyles();
+  const { mobile, md } = useResponsive();
+  const menuBtnOnClick = () => {
+    let status;
+    if (layout === "inline" && mobile || layout === "horizontal" && !md) {
+      if (collapsed) {
+        setCollapsed(false);
+      }
+      status = !open;
+      setOpen(status);
+    } else {
+      status = !collapsed;
+      setCollapsed(status);
+    }
+    onMenuBtnClick?.(status);
+  };
+  useImperativeHandle(ref, () => ({
+    collapsedMenu: () => {
+      setCollapsed(true);
+      setOpen(false);
+    },
+    unCollapsedMenu: () => {
+      setCollapsed(false);
+      setOpen(false);
+    },
+    toggleCollapsedMenu: () => {
+      const status = !collapsed;
+      setCollapsed(status);
+      setOpen(false);
+      onMenuBtnClick?.(status);
+    }
+  }));
+  const getColor = () => {
+    const mode = systemTheme?.isDarkMode ? "light" : menuTheme === "dark" ? menuTheme : "light";
+    return !systemTheme?.isDarkMode && mode === "dark" ? " " + darkColor : "";
+  };
+  const getWaterMaskFont = () => {
+    return {
+      color: systemTheme?.isDarkMode ? "rgba(255, 255, 255, 0.03)" : "rgba(0, 0, 0, 0.07)"
+    };
+  };
+  const getSider = (mode) => {
+    const layoutMode = mode === "horizontal" ? mode : "inline";
+    const theme2 = menuTheme === "dark" ? menuTheme : "light";
+    const routePaths = Array.isArray(matchedRoutes) ? typeof matchedRoutes[0] === "string" ? matchedRoutes : matchedRoutes.map((route) => route?.pathname || route) : [];
+    return /* @__PURE__ */ jsx(
+      sider_default,
+      {
+        classNames: menuClassNames,
+        layout: layoutMode,
+        theme: theme2,
+        collapsed,
+        pathname,
+        matchedRoutes: routePaths,
+        onNavigate,
+        onLogoClick,
+        collapsedLogo,
+        unCollapsedLogo,
+        menuBottomBtnIcon,
+        menuBottomBtnText,
+        onMenuBottomBtnClick,
+        menus,
+        onMenuClick: (item) => {
+          setOpen(false);
+          onMenuClick?.(item);
+        }
+      }
+    );
+  };
+  const getOutlet = () => {
+    return /* @__PURE__ */ jsx(Watermark, { gap: [200, 200], font: getWaterMaskFont(), content: waterMark, children });
+  };
+  const drawer = /* @__PURE__ */ jsx(
+    Drawer,
+    {
+      placement: "left",
+      closable: false,
+      open,
+      width: menuUnCollapsedWidth,
+      classNames: { body: drawMenu },
+      onClose: () => {
+        setOpen(false);
+      },
+      children: getSider("inline")
+    }
+  );
+  const LayoutNormal = /* @__PURE__ */ jsxs(Layout, { className: container, children: [
+    mobile && drawer,
+    /* @__PURE__ */ jsx(
+      Layout.Sider,
+      {
+        className: sider,
+        trigger: null,
+        collapsible: true,
+        collapsed,
+        width: menuUnCollapsedWidth,
+        collapsedWidth: menuCollapsedWidth,
+        hidden: mobile,
+        children: getSider(layout)
+      }
+    ),
+    /* @__PURE__ */ jsxs(Layout, { className: body, children: [
+      !headerHidden && /* @__PURE__ */ jsx(Layout.Header, { className: cx(header, headerFixed && sticky), children: /* @__PURE__ */ jsx(
+        header_default,
+        {
+          left: /* @__PURE__ */ jsxs("div", { children: [
+            /* @__PURE__ */ jsx(
+              Button,
+              {
+                type: "text",
+                size: "large",
+                icon: collapsed ? /* @__PURE__ */ jsx(MenuUnfoldOutlined, {}) : /* @__PURE__ */ jsx(MenuFoldOutlined, {}),
+                onClick: menuBtnOnClick,
+                className: menuBtn
+              }
+            ),
+            headerLeft
+          ] }),
+          right: headerRight
+        }
+      ) }),
+      /* @__PURE__ */ jsxs(Layout.Content, { className: cx(inlineContent, flowLayout && flowContent), children: [
+        /* @__PURE__ */ jsx(
+          breadcrumb_default,
+          {
+            enabled: breadCrumb,
+            items: breadCrumbItems,
+            hideBreadCrumb
+          }
+        ),
+        getOutlet()
+      ] }),
+      props?.footer && /* @__PURE__ */ jsx(Layout.Footer, { className: footer, children: /* @__PURE__ */ jsxs(footer_default, { children: [
+        " ",
+        props?.footer
+      ] }) })
+    ] })
+  ] });
+  const LayoutFlow = /* @__PURE__ */ jsxs(Layout, { className: layoutNormal, children: [
+    /* @__PURE__ */ jsxs(Layout.Header, { className: cx(header, headerFixed && sticky), children: [
+      !md && /* @__PURE__ */ jsx(header_default, { left: /* @__PURE__ */ jsxs("div", { children: [
+        /* @__PURE__ */ jsx(
+          Button,
+          {
+            type: "text",
+            size: "large",
+            icon: collapsed ? /* @__PURE__ */ jsx(MenuUnfoldOutlined, {}) : /* @__PURE__ */ jsx(MenuFoldOutlined, {}),
+            onClick: menuBtnOnClick,
+            className: menuBtn
+          }
+        ),
+        headerLeft
+      ] }), right: headerRight }),
+      !md && drawer || /* @__PURE__ */ jsxs("div", { className: cx(flow, getColor()), children: [
+        /* @__PURE__ */ jsx("div", { className: logo, children: unCollapsedLogo?.(!systemTheme?.isDarkMode) }),
+        getSider(layout),
+        /* @__PURE__ */ jsx("div", { children: headerRight })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs(Layout.Content, { className: cx(horizontalContent, flowLayout && flowContent), children: [
+      /* @__PURE__ */ jsx(
+        breadcrumb_default,
+        {
+          enabled: breadCrumb,
+          items: breadCrumbItems,
+          hideBreadCrumb
+        }
+      ),
+      getOutlet()
+    ] }),
+    props?.footer && /* @__PURE__ */ jsx(Layout.Footer, { className: footer, children: /* @__PURE__ */ jsxs(footer_default, { children: [
+      " ",
+      props?.footer
+    ] }) })
+  ] });
+  return /* @__PURE__ */ jsx(App, { children: loading && /* @__PURE__ */ jsx(Loading, {}) || (layout !== "horizontal" ? LayoutNormal : LayoutFlow) });
+});
+var sinking_default = SinKing;
+var Layout4 = forwardRef((props, ref) => {
+  return /* @__PURE__ */ jsx(sinking_default, { ref, ...props });
+});
+var layout_default = Layout4;
+var useStyles6 = createStyles(({ token, isDarkMode }) => {
+  const fontColor = isDarkMode ? "rgba(255,255,255,0.65)" : "rgba(0,0,0,0.65)";
+  const backgroundColor = isDarkMode ? "rgba(255, 255, 255, 0.1) !important" : "rgba(0, 0, 0, 0.05) !important";
+  const fontSize = 12;
+  const pagination = {
+    color: fontColor,
+    fontSize,
+    ".ant-pagination-item-active": {
+      backgroundColor: "transparent !important"
+    },
+    ".ant-pagination-item": {
+      backgroundColor: "transparent !important",
+      "a": {
+        color: fontColor
+      }
+    },
+    ".ant-pagination-options": {
+      display: "block"
+    },
+    ".ant-select": {
+      ".ant-select-selector": {
+        fontSize,
+        transition: "background-color 0.3s ease",
+        color: fontColor,
+        borderColor: "transparent !important",
+        borderRadius: token?.borderRadius + "px !important",
+        backgroundColor
+      }
+    },
+    ".ant-pagination-options-quick-jumper": {
+      "input": {
+        color: fontColor,
+        borderColor: "transparent",
+        borderRadius: token?.borderRadius + "px !important",
+        backgroundColor
+      }
+    }
+  };
+  const btn = {
+    fontSize: fontSize + "px",
+    height: "auto",
+    padding: "5px 10px",
+    borderRadius: token?.borderRadius + "px"
+  };
+  return {
+    formItem: {
+      marginBottom: "0 !important"
+    },
+    formItemLabel: {
+      ".ant-form-item-label": {
+        flex: "0 0 80px"
+      }
+    },
+    formItemBtn: {
+      ".ant-space-item>div": {
+        display: "flex",
+        alignItems: "center",
+        gap: "8px"
+      },
+      ".ant-space-item>a": {
+        textDecoration: "none"
+      }
+    },
+    formButton: {
+      display: "flex",
+      justifyContent: "end",
+      alignItems: "end"
+    },
+    filter: {
+      boxShadow: "0 0px 10px 4px rgba(0, 0, 0, 0.05) !important",
+      backgroundColor: isDarkMode ? "rgba(255, 255, 255, 0.05)" : "rgba(255, 255, 255, 0.6)",
+      backdropFilter: "blur(8px)"
+    },
+    pageCard: {
+      ".ant-card-body": {
+        padding: 15
+      },
+      ".ant-pagination ": pagination
+    },
+    toolCard: {
+      fontSize: token?.fontSizeSM,
+      color: fontColor,
+      ".ant-card-body": {
+        padding: "12px 17px",
+        ".ant-col": {
+          fontSize,
+          "a": {
+            opacity: isDarkMode ? "1" : "0.8"
+          }
+        }
+      },
+      "button": btn
+    },
+    tableCard: {
+      ".ant-card-head": {
+        padding: "10px 15px 0 15px",
+        minHeight: "42px",
+        borderBottom: "none",
+        ".ant-card-extra": {
+          "button": btn
+        }
+      },
+      ".ant-card-body": {
+        padding: "10px"
+      }
+    },
+    table: {
+      ".ant-table-thead": {
+        ".ant-table-cell": {
+          padding: "10px !important",
+          fontSize: token?.fontSize,
+          color: fontColor
+        }
+      },
+      ".ant-table-tbody": {
+        ".ant-table-cell": {
+          padding: "10px !important",
+          fontSize: token?.fontSizeSM + 1,
+          color: fontColor,
+          ".ant-btn": {
+            height: "25px",
+            padding: "10px ",
+            fontSize: token?.fontSizeSM
+          }
+        },
+        ".ant-typography": {
+          fontSize: token?.fontSizeSM + 1,
+          color: fontColor
+        }
+      },
+      ".ant-pagination ": {
+        ...pagination,
+        ...{
+          margin: "15px 15px 5px 15px !important"
+        }
+      }
+    }
+  };
+});
+var useContainerResponsive = (containerRef) => {
+  const [responsive, setResponsive] = useState({
+    xs: false,
+    sm: false,
+    md: false,
+    lg: false,
+    xl: false,
+    xxl: false,
+    mobile: false
+  });
+  const debounce = useCallback((func, wait) => {
+    let timeout;
+    return (...args) => {
+      clearTimeout(timeout);
+      timeout = setTimeout(() => func.apply(null, args), wait);
+    };
+  }, []);
+  const updateResponsive = useCallback((width) => {
+    const newResponsive = {
+      xs: width < 576,
+      sm: width >= 576 && width < 768,
+      md: width >= 768 && width < 992,
+      lg: width >= 992 && width < 1200,
+      xl: width >= 1200 && width < 1600,
+      xxl: width >= 1600,
+      mobile: width < 992
+    };
+    setResponsive((prev) => {
+      const hasChanged = Object.keys(newResponsive).some(
+        (key) => prev[key] !== newResponsive[key]
+      );
+      return hasChanged ? newResponsive : prev;
+    });
+  }, []);
+  const debouncedUpdate = useMemo(
+    () => debounce((width) => updateResponsive(width), 10),
+    [debounce, updateResponsive]
+  );
+  useEffect(() => {
+    const container = containerRef.current;
+    if (!container) return;
+    const handleResize = () => {
+      const width = container.clientWidth;
+      debouncedUpdate(width);
+    };
+    updateResponsive(container.clientWidth);
+    const resizeObserver = new ResizeObserver(handleResize);
+    resizeObserver.observe(container);
+    return () => {
+      resizeObserver.unobserve(container);
+    };
+  }, [containerRef, debouncedUpdate, updateResponsive]);
+  return responsive;
+};
+var ProTableComponent = forwardRef((props, ref) => {
+  const { styles } = useStyles6();
+  const containerRef = useRef(null);
+  const device = useContainerResponsive(containerRef);
+  const requestRef = useRef(null);
+  const {
+    title = void 0,
+    // 表格标题
+    extra = void 0,
+    // 表格额外内容
+    extraRefreshBtn,
+    // 是否显示刷新按钮
+    rowKey = "id",
+    // 行的唯一标识
+    columns = [],
+    // 列配置
+    tableProps = {},
+    // 表格属性
+    pageHidden = false,
+    // 是否隐藏分页
+    pageInTable = false,
+    // 是否在表格中显示分页
+    paginationProps = {},
+    // 分页属性
+    defaultPage = 1,
+    //默认分页
+    defaultPageSize = 10,
+    //默认分页容量
+    search = {},
+    // 搜索表单配置
+    request = void 0,
+    // 请求函数
+    rowSelection = false,
+    // 多选配置
+    selectionAffix = false,
+    // 是否固定多选操作栏
+    paginationAffix = false,
+    // 是否固定底部分页栏
+    virtual = false
+    // 是否启用虚拟滚动
+  } = props;
+  const [form] = Form.useForm();
+  const [collapsed, setCollapsed] = useState(true);
+  const [data, setData] = useState([]);
+  const [loading, setLoading] = useState(true);
+  const [params, setParams] = useState({});
+  const [sort, setSort] = useState({});
+  const [page, setPage] = useState(defaultPage);
+  const [pageSize, setPageSize] = useState(defaultPageSize);
+  const [total, setTotal] = useState(0);
+  const formatValues = useCallback((values) => {
+    const transformedValues = { ...values };
+    Object.keys(transformedValues).forEach((key) => {
+      if (!transformedValues[key]) {
+        delete transformedValues[key];
+      }
+    });
+    columns.forEach((column) => {
+      const { dataIndex, transform, valueType } = column;
+      const value = values[dataIndex];
+      if (value !== void 0 && value !== null && value !== "") {
+        if (transform) {
+          const transformed = transform?.(value);
+          if (typeof transformed === "object" && transformed !== null) {
+            Object.assign(transformedValues, transformed);
+            delete transformedValues[column?.dataIndex];
+          } else {
+            transformedValues[dataIndex] = transformed;
+          }
+        } else {
+          switch (valueType) {
+            case "dateRange":
+            case "dateTimeRange":
+            case "timeRange":
+              if (Array.isArray(value) && value.length === 2) {
+                const formatStr = "YYYY-MM-DD HH:mm:ss";
+                transformedValues[`${dataIndex}_start`] = value[0]?.format ? value[0].format(formatStr) : value[0];
+                transformedValues[`${dataIndex}_end`] = value[1]?.format ? value[1].format(formatStr) : value[1];
+              }
+              break;
+            case "date":
+              transformedValues[dataIndex] = value?.format ? value.format("YYYY-MM-DD 00:00:00") : value;
+              break;
+            case "dateTime":
+              transformedValues[dataIndex] = value?.format ? value.format("YYYY-MM-DD HH:mm:ss") : value;
+              break;
+            case "time":
+              if (value?.format) {
+                const today = dayjs().format("YYYY-MM-DD");
+                transformedValues[dataIndex] = `${today} ${value.format("HH:mm:ss")}`;
+              } else {
+                transformedValues[dataIndex] = value;
+              }
+              break;
+            case "switch":
+              transformedValues[dataIndex] = value;
+              break;
+            default:
+              transformedValues[dataIndex] = value;
+          }
+        }
+      } else if (value === false && valueType === "switch") {
+        if (transform) {
+          const transformed = transform(value);
+          if (typeof transformed === "object" && transformed !== null) {
+            Object.assign(transformedValues, transformed);
+          } else {
+            transformedValues[dataIndex] = transformed;
+          }
+        } else {
+          transformedValues[dataIndex] = value;
+        }
+      }
+    });
+    return transformedValues;
+  }, [columns]);
+  const onFinish = useCallback((values) => {
+    setPage(1);
+    setParams(formatValues(values));
+  }, [formatValues]);
+  const onReset = useCallback(() => {
+    if (params && Object.keys(params).length > 0 || page > 1) {
+      form?.resetFields();
+      setPage(1);
+      setParams({});
+    }
+  }, [params, page, form]);
+  const getSearchFormItem = useMemo(() => {
+    let elements = [];
+    let sum = 0;
+    let sumAll = 0;
+    let skip = 1;
+    let span = 24;
+    if (device.xl || device.xxl || device.lg) {
+      skip = 3;
+      span = 6;
+    } else if (device.md) {
+      skip = 2;
+      span = 8;
+    } else if (device.sm) {
+      skip = 1;
+      span = 12;
+    }
+    const renderFormField = (column) => {
+      const { valueType, valueEnum, dataIndex, title: title2, props: props2 = {} } = column;
+      const placeholder = `\u8BF7\u8F93\u5165${title2 || dataIndex}`;
+      if (valueEnum) {
+        return /* @__PURE__ */ jsx(Select, { placeholder: `\u8BF7\u9009\u62E9${title2 || dataIndex}`, allowClear: true, ...props2, children: Object.entries(valueEnum).map(([key, value]) => /* @__PURE__ */ jsx(Select.Option, { value: key, children: value.text }, key)) });
+      }
+      switch (valueType) {
+        case "date":
+          return /* @__PURE__ */ jsx(DatePicker, { style: { width: "100%" }, placeholder, ...props2 });
+        case "dateTime":
+          return /* @__PURE__ */ jsx(DatePicker, { showTime: true, style: { width: "100%" }, placeholder, ...props2 });
+        case "dateRange":
+          return /* @__PURE__ */ jsx(DatePicker.RangePicker, { style: { width: "100%" }, ...props2 });
+        case "dateTimeRange":
+          return /* @__PURE__ */ jsx(DatePicker.RangePicker, { showTime: true, style: { width: "100%" }, ...props2 });
+        case "time":
+          return /* @__PURE__ */ jsx(TimePicker, { style: { width: "100%" }, placeholder, ...props2 });
+        case "timeRange":
+          return /* @__PURE__ */ jsx(TimePicker.RangePicker, { style: { width: "100%" }, ...props2 });
+        case "digit":
+          return /* @__PURE__ */ jsx(InputNumber, { style: { width: "100%" }, placeholder, ...props2 });
+        case "rate":
+          return /* @__PURE__ */ jsx(Rate, { allowHalf: true, ...props2 });
+        case "switch":
+          return /* @__PURE__ */ jsx(Switch, { ...props2 });
+        case "percent":
+          return /* @__PURE__ */ jsx(
+            InputNumber,
+            {
+              style: { width: "100%" },
+              placeholder,
+              formatter: (value) => `${value}%`,
+              parser: (value) => value.replace("%", ""),
+              ...props2
+            }
+          );
+        case "progress":
+          return /* @__PURE__ */ jsx(
+            InputNumber,
+            {
+              style: { width: "100%" },
+              placeholder,
+              min: 0,
+              max: 100,
+              ...props2
+            }
+          );
+        case "select":
+          return /* @__PURE__ */ jsx(Select, { placeholder: `\u8BF7\u9009\u62E9${title2 || dataIndex}`, allowClear: true, ...props2 });
+        default:
+          return /* @__PURE__ */ jsx(Input, { placeholder, ...props2 });
+      }
+    };
+    let hide = false;
+    columns.forEach((column, index) => {
+      if (column?.hideInSearch === true) {
+        return;
+      }
+      if (!hide) {
+        sumAll++;
+      }
+      if (skip > 0 && collapsed && sum >= skip) {
+        hide = true;
+      }
+      if (!hide) {
+        sum++;
+      }
+      const { formItemProps = {} } = column;
+      elements.push(/* @__PURE__ */ jsx(
+        Col,
+        {
+          span,
+          style: { display: hide ? "none" : "block" },
+          className: search?.layout && search?.layout != "vertical" ? " " + styles.formItemLabel : "",
+          children: /* @__PURE__ */ jsx(
+            Form.Item,
+            {
+              className: styles.formItem,
+              label: column?.title || column?.dataIndex,
+              labelAlign: "right",
+              colon: true,
+              tooltip: column?.tip || void 0,
+              name: column?.dataIndex,
+              ...formItemProps,
+              children: renderFormField(column)
+            }
+          )
+        },
+        column?.dataIndex + index
+      ));
+    });
+    let offset = 0;
+    if (device.xl || device.xxl || device.lg) {
+      if (sum <= 3) {
+        offset = (4 - sum - 1) * 6;
+      } else {
+        offset = sum % 4;
+        if (offset <= 0) {
+          offset = 18;
+        } else {
+          offset = 24 - (offset + 1) * 6;
+        }
+      }
+    } else if (device.md) {
+      if (sum <= 2) {
+        offset = (3 - sum - 1) * 8;
+      } else {
+        offset = sum % 3;
+        if (offset <= 0) {
+          offset = 16;
+        } else {
+          offset = 24 - (offset + 1) * 8;
+        }
+      }
+    } else if (device.sm) {
+      if (sum <= 1) {
+        offset = (2 - sum - 1) * 12;
+      } else {
+        offset = sum % 2;
+        if (offset <= 0) {
+          offset = 12;
+        } else {
+          offset = 24 - (offset + 1) * 12;
+        }
+      }
+    } else if (device.xs) {
+      offset = 0;
+    }
+    if (offset <= 0) {
+      offset = 0;
+    }
+    elements.push(/* @__PURE__ */ jsx(
+      Col,
+      {
+        span,
+        offset,
+        className: styles.formButton,
+        children: /* @__PURE__ */ jsx(Form.Item, { className: styles.formItem, children: /* @__PURE__ */ jsxs(Space, { align: "center", size: 16, className: styles.formItemBtn, children: [
+          /* @__PURE__ */ jsxs("div", { children: [
+            /* @__PURE__ */ jsx(Button, { htmlType: "reset", children: "\u91CD\u7F6E" }),
+            /* @__PURE__ */ jsx(Button, { type: "primary", htmlType: "submit", loading, children: "\u67E5\u8BE2" })
+          ] }),
+          sumAll > skip && /* @__PURE__ */ jsx("a", { onClick: () => setCollapsed(!collapsed), children: collapsed ? /* @__PURE__ */ jsxs(Fragment, { children: [
+            "\u5C55\u5F00 ",
+            /* @__PURE__ */ jsx(DownOutlined, {})
+          ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+            "\u6536\u8D77 ",
+            /* @__PURE__ */ jsx(UpOutlined, {})
+          ] }) })
+        ] }) })
+      },
+      "action" + (sum + 2)
+    ));
+    return /* @__PURE__ */ jsx(Row, { gutter: [20, 20], children: elements });
+  }, [columns, collapsed, device, loading, search, styles, form]);
+  const renderTableCell = useCallback((text, record, column) => {
+    const { valueType, valueEnum, copyable, props: props2 = {} } = column;
+    if (valueEnum && text !== void 0 && text !== null) {
+      const enumItem = valueEnum[text];
+      if (enumItem) {
+        const { text: label, color } = enumItem;
+        if (color) {
+          const colorMap = {
+            success: "success",
+            warning: "warning",
+            error: "error",
+            default: "default",
+            processing: "processing"
+          };
+          return /* @__PURE__ */ jsx(
+            Tag,
+            {
+              color: colorMap[color] || color || "default",
+              bordered: false,
+              ...props2,
+              children: label
+            }
+          );
+        }
+        return label;
+      }
+    }
+    let content;
+    switch (valueType) {
+      case "date":
+        content = text ? dayjs(text).format("YYYY-MM-DD") : "-";
+        break;
+      case "dateTime":
+        content = text ? dayjs(text).format("YYYY-MM-DD HH:mm:ss") : "-";
+        break;
+      case "time":
+        content = text ? dayjs(text).format("HH:mm:ss") : "-";
+        break;
+      case "percent":
+        content = /* @__PURE__ */ jsx(Progress, { percent: Number(text) || 0, size: "small", ...props2 });
+        break;
+      case "progress":
+        content = /* @__PURE__ */ jsx(Progress, { percent: Number(text) || 0, size: "small", ...props2 });
+        break;
+      case "rate":
+        content = /* @__PURE__ */ jsx(Rate, { disabled: true, value: Number(text) || 0, ...props2 });
+        break;
+      case "switch":
+        content = /* @__PURE__ */ jsx(Switch, { checked: !!text, disabled: true, ...props2 });
+        break;
+      case "digit":
+        content = typeof text === "number" ? text.toLocaleString() : text;
+        break;
+      default:
+        content = text || "-";
+    }
+    if (copyable && text) {
+      return /* @__PURE__ */ jsx(Typography.Text, { copyable: true, children: content });
+    }
+    return content;
+  }, []);
+  const getTableColumns = useMemo(() => {
+    const list = [];
+    columns.forEach((column) => {
+      if (column?.hideInTable === true) return;
+      const newColumn = {
+        ...column,
+        // 使用稳定的 render 函数引用
+        render: column.render || ((text, record) => {
+          return renderTableCell(text, record, column);
+        })
+      };
+      if (column.tip && typeof column.title === "string") {
+        const originalTitle = column.title;
+        newColumn.title = () => /* @__PURE__ */ jsxs(Space, { size: "small", children: [
+          originalTitle,
+          /* @__PURE__ */ jsx(Tooltip, { title: column.tip, children: /* @__PURE__ */ jsx(QuestionCircleOutlined, {}) })
+        ] });
+      }
+      list.push(newColumn);
+    });
+    return list;
+  }, [columns, renderTableCell]);
+  requestRef.current = request;
+  const requestData = useCallback(() => {
+    const currentRequest = requestRef.current;
+    if (!currentRequest) {
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    const param = { ...params };
+    param.current = page;
+    param.pageSize = pageSize;
+    const sorter = { ...sort };
+    currentRequest(param, sorter).then((res) => {
+      if (res?.success) {
+        setData(res?.data || []);
+        setTotal(res?.total || 0);
+      }
+    }).finally(() => {
+      setLoading(false);
+    });
+  }, [params, page, pageSize, sort]);
+  useEffect(() => {
+    requestData();
+  }, [requestData]);
+  const getTableExtra = useMemo(() => {
+    if (!extraRefreshBtn && !extra) {
+      return false;
+    }
+    return /* @__PURE__ */ jsxs(Space, { children: [
+      extra,
+      extraRefreshBtn && /* @__PURE__ */ jsx(
+        Button,
+        {
+          color: "default",
+          style: {
+            fontSize: "15px",
+            opacity: "0.7"
+          },
+          variant: "link",
+          icon: /* @__PURE__ */ jsx(RedoOutlined, { rotate: 260 }),
+          onClick: requestData
+        }
+      )
+    ] });
+  }, [extraRefreshBtn, extra, requestData]);
+  const [selectedRowKeys, setSelectedRowKeys] = useState([]);
+  const [selectedRows, setSelectedRows] = useState([]);
+  const clearSelectedRow = useCallback(() => {
+    setSelectedRowKeys([]);
+    setSelectedRows([]);
+    if (rowSelection && typeof rowSelection === "object" && rowSelection.onChange) {
+      rowSelection.onChange([], []);
+    }
+  }, [rowSelection]);
+  const invertSelectedRow = useCallback(() => {
+    const allKeys = data.map((item) => item[rowKey]);
+    const newSelectedKeys = allKeys.filter((key) => !selectedRowKeys.includes(key));
+    setSelectedRowKeys(newSelectedKeys);
+    const newSelectedRows = data.filter((item) => newSelectedKeys.includes(item[rowKey]));
+    setSelectedRows(newSelectedRows);
+    if (rowSelection && typeof rowSelection === "object" && rowSelection.onChange) {
+      rowSelection.onChange(newSelectedKeys, newSelectedRows);
+    }
+  }, [data, rowKey, selectedRowKeys, rowSelection]);
+  const allSelectedRow = useCallback(() => {
+    const allKeys = data.map((item) => item[rowKey]);
+    setSelectedRowKeys(allKeys);
+    setSelectedRows(data);
+    if (rowSelection && typeof rowSelection === "object" && rowSelection.onChange) {
+      rowSelection.onChange(allKeys, data);
+    }
+  }, [data, rowKey, rowSelection]);
+  const handleSelectChange = useCallback((newSelectedRowKeys, newSelectedRows) => {
+    setSelectedRowKeys(newSelectedRowKeys);
+    setSelectedRows(newSelectedRows);
+    if (rowSelection && typeof rowSelection === "object" && rowSelection?.onChange) {
+      rowSelection?.onChange(newSelectedRowKeys, newSelectedRows);
+    }
+  }, [rowSelection]);
+  const handleSelect = useCallback((record, selected, selectedRows2) => {
+    if (rowSelection && typeof rowSelection === "object" && rowSelection?.onSelect) {
+      rowSelection?.onSelect(record, selected, selectedRows2);
+    }
+  }, [rowSelection]);
+  const handleSelectAll = useCallback((selected, selectedRows2, changeRows) => {
+    if (rowSelection && typeof rowSelection === "object" && rowSelection?.onSelectAll) {
+      rowSelection?.onSelectAll(selected, selectedRows2, changeRows);
+    }
+  }, [rowSelection]);
+  const handleSelectInvert = useCallback((selectedRowKeys2) => {
+    if (rowSelection && typeof rowSelection === "object" && rowSelection?.onSelectInvert) {
+      rowSelection?.onSelectInvert(selectedRowKeys2);
+    }
+  }, [rowSelection]);
+  const getRowSelection = useMemo(() => {
+    if (rowSelection === false) {
+      return void 0;
+    }
+    const select = {
+      selectedRowKeys: rowSelection?.selectedRowKeys || selectedRowKeys,
+      onChange: handleSelectChange,
+      onSelect: handleSelect,
+      onSelectAll: handleSelectAll,
+      onSelectInvert: handleSelectInvert
+    };
+    return {
+      ...{
+        align: rowSelection?.align || "center",
+        columnWidth: rowSelection?.columnWidth || 50,
+        fixed: rowSelection?.fixed || false,
+        selections: [
+          {
+            key: "all",
+            text: "\u5168\u90E8\u9009\u4E2D",
+            onSelect: allSelectedRow
+          },
+          {
+            key: "invert",
+            text: "\u53CD\u5411\u9009\u4E2D",
+            onSelect: invertSelectedRow
+          },
+          {
+            key: "clear",
+            text: "\u6E05\u7A7A\u9009\u4E2D",
+            onSelect: clearSelectedRow
+          }
+        ]
+      },
+      ...rowSelection,
+      ...select
+    };
+  }, [rowSelection, selectedRowKeys, handleSelectChange, handleSelect, handleSelectAll, handleSelectInvert, allSelectedRow, invertSelectedRow, clearSelectedRow]);
+  const setSelectedRowKey = useCallback((keys) => {
+    setSelectedRowKeys(keys);
+    const rows = data.filter((item) => keys.includes(item[rowKey]));
+    setSelectedRows(rows);
+    if (rowSelection && typeof rowSelection === "object" && rowSelection.onChange) {
+      rowSelection.onChange(keys, rows);
+    }
+  }, [data, rowKey, rowSelection]);
+  useImperativeHandle(ref, () => ({
+    searchForm: form,
+    refreshTableData: requestData,
+    resetTableData: onReset,
+    getTableData: () => {
+      return {
+        data,
+        page,
+        pageSize,
+        sort,
+        total
+      };
+    },
+    getSelectedRowKeys: () => selectedRowKeys,
+    getSelectedRows: () => selectedRows,
+    setSelectedRowKeys: setSelectedRowKey,
+    clearSelectedRows: clearSelectedRow,
+    invertSelectedRow,
+    allSelectedRow
+  }));
+  const [selectionBarAffix, setSelectionBarAffix] = useState(false);
+  const renderSelectionBar = useCallback(() => {
+    if ((selectedRowKeys?.length || 0) <= 0) return null;
+    const content = /* @__PURE__ */ jsx(
+      Card,
+      {
+        className: styles.toolCard + (selectionBarAffix ? " " + styles.filter : ""),
+        variant: "borderless",
+        children: /* @__PURE__ */ jsxs(Row, { justify: "space-between", align: "middle", children: [
+          /* @__PURE__ */ jsx(Col, { children: typeof rowSelection?.leftExtra === "function" && rowSelection?.leftExtra?.(selectedRowKeys, selectedRows) || rowSelection?.leftExtra || /* @__PURE__ */ jsxs(Fragment, { children: [
+            "\u5DF2\u9009\u62E9 ",
+            selectedRowKeys?.length,
+            " \u9879 ",
+            /* @__PURE__ */ jsx(
+              "a",
+              {
+                onClick: clearSelectedRow,
+                children: "\u53D6\u6D88\u9009\u62E9"
+              }
+            )
+          ] }) }),
+          /* @__PURE__ */ jsx(Col, { children: /* @__PURE__ */ jsx(Space, { children: typeof rowSelection?.rightExtra === "function" && rowSelection?.rightExtra?.(selectedRowKeys, selectedRows) || rowSelection?.rightExtra }) })
+        ] })
+      }
+    );
+    if (rowSelection?.hideExtra === true) {
+      return false;
+    }
+    return /* @__PURE__ */ jsx(Col, { span: (selectedRowKeys?.length || 0) <= 0 ? 0 : 24, children: selectionAffix ? /* @__PURE__ */ jsx(Affix, { offsetTop: 5, onChange: (affixed) => setSelectionBarAffix(affixed || false), children: content }) : content });
+  }, [selectedRowKeys, selectedRows, rowSelection, selectionAffix, selectionBarAffix, styles, clearSelectedRow]);
+  const [pageAffix, setPageAffix] = useState(false);
+  const renderPagination = useCallback(() => {
+    if (pageHidden || pageInTable || total <= 0) return null;
+    const content = /* @__PURE__ */ jsx(
+      Card,
+      {
+        className: styles.pageCard + (pageAffix ? " " + styles.filter : ""),
+        variant: "borderless",
+        children: /* @__PURE__ */ jsx(
+          Pagination,
+          {
+            align: "center",
+            showTotal: (total2, range) => device?.xs || device?.sm ? false : `\u7B2C ${range[0]}-${range[1]} \u6761 / \u5171 ${total2} \u6761`,
+            showQuickJumper: !(device?.xs || device?.sm),
+            pageSizeOptions: [10, 20, 50, 100],
+            ...paginationProps,
+            showSizeChanger: {
+              showSearch: false,
+              variant: "filled",
+              size: "small"
+            },
+            showLessItems: true,
+            size: "small",
+            current: page,
+            pageSize,
+            total,
+            onChange: (page2, pageSize2) => {
+              setPage(page2);
+              setPageSize(pageSize2);
+            }
+          }
+        )
+      }
+    );
+    return paginationAffix ? /* @__PURE__ */ jsx(Affix, { offsetBottom: 5, onChange: (affixed) => setPageAffix(affixed || false), children: content }) : content;
+  }, [pageHidden, pageInTable, total, page, pageSize, paginationProps, device, pageAffix, paginationAffix, styles]);
+  return /* @__PURE__ */ jsxs(Row, { gutter: [15, 15], ref: containerRef, children: [
+    /* @__PURE__ */ jsx(Col, { span: !search ? 0 : 24, children: /* @__PURE__ */ jsx(Card, { variant: "borderless", children: /* @__PURE__ */ jsx(
+      Form,
+      {
+        layout: search?.layout || "vertical",
+        form,
+        onReset,
+        onFinish,
+        children: getSearchFormItem
+      }
+    ) }) }),
+    renderSelectionBar(),
+    /* @__PURE__ */ jsx(Col, { span: 24, children: /* @__PURE__ */ jsx(Card, { title, extra: getTableExtra, className: styles.tableCard, variant: "borderless", children: /* @__PURE__ */ jsx(
+      Table,
+      {
+        rowKey,
+        className: styles.table,
+        style: { overflowX: "auto", whiteSpace: "nowrap" },
+        scroll: { x: true, y: virtual ? 500 : void 0 },
+        virtual,
+        ...tableProps,
+        rowSelection: getRowSelection,
+        pagination: !pageHidden && pageInTable ? {
+          ...{
+            pageSizeOptions: [10, 20, 50, 100]
+          },
+          ...paginationProps,
+          ...{
+            current: page,
+            pageSize,
+            total,
+            size: "small",
+            showSizeChanger: {
+              showSearch: false,
+              variant: "filled",
+              size: "small"
+            },
+            showQuickJumper: !(device?.xs || device?.sm),
+            showLessItems: true,
+            showTotal: (total2, range) => device?.xs || device?.sm ? false : `\u7B2C ${range[0]}-${range[1]} \u6761 / \u5171 ${total2} \u6761`,
+            onChange: (page2, pageSize2) => {
+              setPage(page2);
+              setPageSize(pageSize2);
+            }
+          }
+        } : false,
+        size: "small",
+        columns: getTableColumns,
+        dataSource: data,
+        loading,
+        onChange: useCallback((_, filters, sorter) => {
+          if (Object.keys(filters).length > 0) {
+            setParams((prev) => ({ ...prev, ...filters }));
+          }
+          if (Object.keys(sorter).length > 0 && sorter?.field) {
+            let temp = {};
+            temp[sorter?.field] = sorter?.order;
+            setSort(temp);
+          }
+        }, [])
+      }
+    ) }) }),
+    !pageHidden && !pageInTable && total > 0 && /* @__PURE__ */ jsx(Col, { span: 24, children: renderPagination() })
+  ] });
+});
+var pro_table_default = ProTableComponent;
+var ProModal = forwardRef((props, ref) => {
+  const {
+    modalProps = {},
+    title,
+    onOk,
+    onCancel,
+    afterClose,
+    okText,
+    okType,
+    width = 520,
+    afterOpenChange,
+    children
+  } = props;
+  const theme2 = useTheme();
+  const [internalOpen, setInternalOpen] = useState(false);
+  const isControlled = modalProps?.open !== void 0;
+  const open = isControlled ? modalProps?.open : internalOpen;
+  const adjustedWidth = theme2?.isCompactTheme?.() ? typeof width === "number" ? Math.floor(width * 0.87) : width : width;
+  const handleOk = async () => {
+    await onOk?.();
+  };
+  const handleCancel = () => {
+    if (onCancel) {
+      onCancel();
+    } else if (!isControlled) {
+      setInternalOpen(false);
+      afterOpenChange?.(false);
+    }
+  };
+  const handleAfterClose = () => {
+    afterClose?.();
+  };
+  useImperativeHandle(ref, () => ({
+    show: () => {
+      if (!isControlled) {
+        setInternalOpen(true);
+      }
+      afterOpenChange?.(true);
+    },
+    hide: () => {
+      if (!isControlled) {
+        setInternalOpen(false);
+      }
+      afterOpenChange?.(false);
+    }
+  }));
+  return /* @__PURE__ */ jsx(
+    Modal$1,
+    {
+      title,
+      open,
+      onOk: handleOk,
+      onCancel: handleCancel,
+      afterClose: handleAfterClose,
+      okText,
+      okType,
+      width: adjustedWidth,
+      maskClosable: false,
+      ...modalProps,
+      children
+    }
+  );
+});
+var pro_modal_default = ProModal;
+
+export { Animate, animation_default as Animation, antd_default as Antd, body_default as Body, breadcrumb_default as Breadcrumb, footer_default as Footer, header_default as Header, Icon, IconFontProvider, layout_default as Layout, Message, Modal, Notification, pro_modal_default as ProModal, pro_table_default as ProTable, sider_default as Sider, theme_default as Theme, title_default as Title, getAllIconNames, getAntdIconNames, getIconfontIconNames, getIconfontUrl, setIconfontUrl, useTheme };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map