@ahooks.js/dumi-theme-antd 0.1.5 → 0.1.6

package/dist/slots/Header/Navigation.js

@@ -0,0 +1,140 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import { MenuFoldOutlined } from '@ant-design/icons';
+import { css } from '@emotion/react';
+import { Menu } from 'antd';
+import { Link, useLocale, useLocation, useNavData, useSiteData } from 'dumi';
+import { useCallback } from 'react';
+import useAdditionalThemeConfig from "../../hooks/useAdditionalThemeConfig";
+import useLocaleValue from "../../hooks/useLocaleValue";
+import useSiteToken from "../../hooks/useSiteToken";
+import { getTargetLocalePath, isExternalLinks } from "../../utils";
+import { getMoreLinksGroup } from "./More";
+import { jsx as ___EmotionJSX } from "@emotion/react";
+var getWithoutLocaleFirstPath = function getWithoutLocaleFirstPath(pathname, localeBase) {
+  if (!pathname) return '';
+  if (!localeBase || isExternalLinks(pathname)) return pathname;
+  var splitPaths = pathname.split('/').filter(Boolean);
+  var pathLocalePrefix = localeBase === '/' ? '' : localeBase;
+  var firstPath = splitPaths.slice(0, pathLocalePrefix ? 2 : 1).join('/');
+  return firstPath;
+};
+var useStyle = function useStyle() {
+  var _useSiteToken = useSiteToken(),
+    token = _useSiteToken.token;
+  var antCls = token.antCls,
+    iconCls = token.iconCls,
+    fontFamily = token.fontFamily,
+    headerHeight = token.headerHeight,
+    menuItemBorder = token.menuItemBorder,
+    colorPrimary = token.colorPrimary;
+  return {
+    nav: /*#__PURE__*/css("height:100%;font-size:14px;font-family:Avenir,", fontFamily, ",sans-serif;border:0;&", antCls, "-menu-horizontal{border-bottom:none;&>", antCls, "-menu-item,&>", antCls, "-menu-submenu{min-width:(40px + 12px * 2);height:", headerHeight, "px;padding-right:12px;padding-left:12px;line-height:", headerHeight, "px;&::after{top:0;right:12px;bottom:auto;left:12px;border-width:", menuItemBorder, "px;}}& ", antCls, "-menu-submenu-title ", iconCls, "{margin:0;}&>", antCls, "-menu-item-selected{a{color:", colorPrimary, ";}}}&>", antCls, "-menu-item,&>", antCls, "-menu-submenu{text-align:center;}" + (process.env.NODE_ENV === "production" ? "" : ";label:nav;"), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["Navigation.tsx"],"names":[],"mappings":"AAsCY","file":"Navigation.tsx","sourcesContent":["import { MenuFoldOutlined } from '@ant-design/icons';\nimport { css } from '@emotion/react';\nimport type { MenuProps } from 'antd';\nimport { Menu } from 'antd';\nimport { MenuItemType } from 'antd/es/menu/hooks/useItems';\nimport { Link, useLocale, useLocation, useNavData, useSiteData } from 'dumi';\nimport { useCallback } from 'react';\nimport useAdditionalThemeConfig from '../../hooks/useAdditionalThemeConfig';\nimport useLocaleValue from '../../hooks/useLocaleValue';\nimport useSiteToken from '../../hooks/useSiteToken';\nimport { getTargetLocalePath, isExternalLinks } from '../../utils';\nimport { type IResponsive } from './index';\nimport { getMoreLinksGroup } from './More';\n\ntype MenuItemsType = Required<MenuProps>['items'];\n\nexport interface NavigationProps {\n  isMobile: boolean;\n  responsive: IResponsive;\n}\n\nconst getWithoutLocaleFirstPath = (pathname?: string, localeBase?: string) => {\n  if (!pathname) return '';\n  if (!localeBase || isExternalLinks(pathname)) return pathname;\n\n  const splitPaths = pathname.split('/').filter(Boolean);\n  const pathLocalePrefix = localeBase === '/' ? '' : localeBase;\n  const firstPath = splitPaths.slice(0, pathLocalePrefix ? 2 : 1).join('/');\n\n  return firstPath;\n};\n\nconst useStyle = () => {\n  const { token } = useSiteToken();\n\n  const { antCls, iconCls, fontFamily, headerHeight, menuItemBorder, colorPrimary } = token;\n\n  return {\n    nav: css`\n      height: 100%;\n      font-size: 14px;\n      font-family: Avenir, ${fontFamily}, sans-serif;\n      border: 0;\n\n      &${antCls}-menu-horizontal {\n        border-bottom: none;\n\n        & > ${antCls}-menu-item, & > ${antCls}-menu-submenu {\n          min-width: (40px + 12px * 2);\n          height: ${headerHeight}px;\n          padding-right: 12px;\n          padding-left: 12px;\n          line-height: ${headerHeight}px;\n\n          &::after {\n            top: 0;\n            right: 12px;\n            bottom: auto;\n            left: 12px;\n            border-width: ${menuItemBorder}px;\n          }\n        }\n\n        & ${antCls}-menu-submenu-title ${iconCls} {\n          margin: 0;\n        }\n\n        & > ${antCls}-menu-item-selected {\n          a {\n            color: ${colorPrimary};\n          }\n        }\n      }\n\n      & > ${antCls}-menu-item, & > ${antCls}-menu-submenu {\n        text-align: center;\n      }\n    `,\n    popoverMenuNav: css`\n      ${antCls}-menu-item,\n      ${antCls}-menu-submenu {\n        text-align: left;\n      }\n\n      ${antCls}-menu-item-group-title {\n        padding-left: 24px;\n      }\n\n      ${antCls}-menu-item-group-list {\n        padding: 0 16px;\n      }\n\n      ${antCls}-menu-item,\n      a {\n        color: #333;\n      }\n    `\n  };\n};\n\nexport default function Navigation({ isMobile, responsive }: NavigationProps) {\n  const { pathname, search } = useLocation();\n  const { locales } = useSiteData();\n  const { github, socialLinks } = useAdditionalThemeConfig();\n\n  // 统一使用 themeConfig.nav，使用 useNavData，当存在自定义 pages 时，会导致 nav 混乱\n  const navList = useNavData();\n  const locale = useLocale() as ReturnType<typeof useLocale> & { base: string };\n  const moreLinks = useLocaleValue('moreLinks');\n  const activeKey = getWithoutLocaleFirstPath(pathname, locale.base);\n\n  const menuItems: MenuItemType[] = (navList ?? [])\n    .map((navItem) => {\n      const { title, link } = navItem || {};\n      const key = getWithoutLocaleFirstPath(link, locale.base);\n      const path = `${link}${search}`;\n\n      return {\n        key,\n        label: isExternalLinks(link) ? (\n          <a href={path} target=\"_blank\" rel=\"noopener noreferrer\">\n            {title}\n          </a>\n        ) : (\n          <Link to={path}>{title}</Link>\n        )\n      } as MenuItemType;\n    })\n    .filter(Boolean);\n\n  // 获取小屏幕下多语言导航栏节点\n  const getLangNode = useCallback(() => {\n    if (locales.length < 2) {\n      return null;\n    }\n    if (locales.length === 2) {\n      const nextLang = locales.filter((item) => item.id !== locale.id)[0];\n      const nextPath = getTargetLocalePath({\n        current: locale,\n        target: nextLang\n      });\n      return {\n        label: (\n          <a rel=\"noopener noreferrer\" href={nextPath}>\n            {nextLang.name}\n          </a>\n        ),\n        key: nextLang.id\n      };\n    }\n    return {\n      label: <span>{locale.name}</span>,\n      key: 'multi-lang',\n      children: locales\n        .filter((item) => item.id !== locale.id)\n        .map((item) => {\n          const nextPath = getTargetLocalePath({\n            current: locale,\n            target: item\n          });\n          return {\n            label: (\n              <a rel=\"noopener noreferrer\" href={nextPath}>\n                {item.name}\n              </a>\n            ),\n            key: item.id\n          };\n        })\n    };\n  }, [locale, locales]);\n\n  let additional: MenuItemsType;\n  const additionalItems: MenuItemsType = [\n    github || socialLinks?.github\n      ? {\n          label: (\n            <a rel=\"noopener noreferrer\" href={github || socialLinks?.github} target=\"_blank\">\n              GitHub\n            </a>\n          ),\n          key: 'github'\n        }\n      : null,\n    getLangNode(),\n    ...(getMoreLinksGroup(moreLinks) || [])\n  ];\n\n  if (isMobile) {\n    additional = additionalItems;\n  } else if (responsive === 'crowded') {\n    additional = [\n      {\n        label: <MenuFoldOutlined />,\n        key: 'additional',\n        children: [...additionalItems]\n      }\n    ];\n  }\n\n  const items: MenuItemsType = [...(menuItems ?? []), ...(additional ?? [])];\n  const menuMode = isMobile ? 'inline' : 'horizontal';\n  const style = useStyle();\n\n  return (\n    <Menu\n      items={items}\n      mode={menuMode}\n      css={style.nav}\n      selectedKeys={[activeKey]}\n      disabledOverflow\n    />\n  );\n}\n"]} */"),
+    popoverMenuNav: /*#__PURE__*/css(antCls, "-menu-item,", antCls, "-menu-submenu{text-align:left;}", antCls, "-menu-item-group-title{padding-left:24px;}", antCls, "-menu-item-group-list{padding:0 16px;}", antCls, "-menu-item,a{color:#333;}" + (process.env.NODE_ENV === "production" ? "" : ";label:popoverMenuNav;"), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["Navigation.tsx"],"names":[],"mappings":"AA8EuB","file":"Navigation.tsx","sourcesContent":["import { MenuFoldOutlined } from '@ant-design/icons';\nimport { css } from '@emotion/react';\nimport type { MenuProps } from 'antd';\nimport { Menu } from 'antd';\nimport { MenuItemType } from 'antd/es/menu/hooks/useItems';\nimport { Link, useLocale, useLocation, useNavData, useSiteData } from 'dumi';\nimport { useCallback } from 'react';\nimport useAdditionalThemeConfig from '../../hooks/useAdditionalThemeConfig';\nimport useLocaleValue from '../../hooks/useLocaleValue';\nimport useSiteToken from '../../hooks/useSiteToken';\nimport { getTargetLocalePath, isExternalLinks } from '../../utils';\nimport { type IResponsive } from './index';\nimport { getMoreLinksGroup } from './More';\n\ntype MenuItemsType = Required<MenuProps>['items'];\n\nexport interface NavigationProps {\n  isMobile: boolean;\n  responsive: IResponsive;\n}\n\nconst getWithoutLocaleFirstPath = (pathname?: string, localeBase?: string) => {\n  if (!pathname) return '';\n  if (!localeBase || isExternalLinks(pathname)) return pathname;\n\n  const splitPaths = pathname.split('/').filter(Boolean);\n  const pathLocalePrefix = localeBase === '/' ? '' : localeBase;\n  const firstPath = splitPaths.slice(0, pathLocalePrefix ? 2 : 1).join('/');\n\n  return firstPath;\n};\n\nconst useStyle = () => {\n  const { token } = useSiteToken();\n\n  const { antCls, iconCls, fontFamily, headerHeight, menuItemBorder, colorPrimary } = token;\n\n  return {\n    nav: css`\n      height: 100%;\n      font-size: 14px;\n      font-family: Avenir, ${fontFamily}, sans-serif;\n      border: 0;\n\n      &${antCls}-menu-horizontal {\n        border-bottom: none;\n\n        & > ${antCls}-menu-item, & > ${antCls}-menu-submenu {\n          min-width: (40px + 12px * 2);\n          height: ${headerHeight}px;\n          padding-right: 12px;\n          padding-left: 12px;\n          line-height: ${headerHeight}px;\n\n          &::after {\n            top: 0;\n            right: 12px;\n            bottom: auto;\n            left: 12px;\n            border-width: ${menuItemBorder}px;\n          }\n        }\n\n        & ${antCls}-menu-submenu-title ${iconCls} {\n          margin: 0;\n        }\n\n        & > ${antCls}-menu-item-selected {\n          a {\n            color: ${colorPrimary};\n          }\n        }\n      }\n\n      & > ${antCls}-menu-item, & > ${antCls}-menu-submenu {\n        text-align: center;\n      }\n    `,\n    popoverMenuNav: css`\n      ${antCls}-menu-item,\n      ${antCls}-menu-submenu {\n        text-align: left;\n      }\n\n      ${antCls}-menu-item-group-title {\n        padding-left: 24px;\n      }\n\n      ${antCls}-menu-item-group-list {\n        padding: 0 16px;\n      }\n\n      ${antCls}-menu-item,\n      a {\n        color: #333;\n      }\n    `\n  };\n};\n\nexport default function Navigation({ isMobile, responsive }: NavigationProps) {\n  const { pathname, search } = useLocation();\n  const { locales } = useSiteData();\n  const { github, socialLinks } = useAdditionalThemeConfig();\n\n  // 统一使用 themeConfig.nav，使用 useNavData，当存在自定义 pages 时，会导致 nav 混乱\n  const navList = useNavData();\n  const locale = useLocale() as ReturnType<typeof useLocale> & { base: string };\n  const moreLinks = useLocaleValue('moreLinks');\n  const activeKey = getWithoutLocaleFirstPath(pathname, locale.base);\n\n  const menuItems: MenuItemType[] = (navList ?? [])\n    .map((navItem) => {\n      const { title, link } = navItem || {};\n      const key = getWithoutLocaleFirstPath(link, locale.base);\n      const path = `${link}${search}`;\n\n      return {\n        key,\n        label: isExternalLinks(link) ? (\n          <a href={path} target=\"_blank\" rel=\"noopener noreferrer\">\n            {title}\n          </a>\n        ) : (\n          <Link to={path}>{title}</Link>\n        )\n      } as MenuItemType;\n    })\n    .filter(Boolean);\n\n  // 获取小屏幕下多语言导航栏节点\n  const getLangNode = useCallback(() => {\n    if (locales.length < 2) {\n      return null;\n    }\n    if (locales.length === 2) {\n      const nextLang = locales.filter((item) => item.id !== locale.id)[0];\n      const nextPath = getTargetLocalePath({\n        current: locale,\n        target: nextLang\n      });\n      return {\n        label: (\n          <a rel=\"noopener noreferrer\" href={nextPath}>\n            {nextLang.name}\n          </a>\n        ),\n        key: nextLang.id\n      };\n    }\n    return {\n      label: <span>{locale.name}</span>,\n      key: 'multi-lang',\n      children: locales\n        .filter((item) => item.id !== locale.id)\n        .map((item) => {\n          const nextPath = getTargetLocalePath({\n            current: locale,\n            target: item\n          });\n          return {\n            label: (\n              <a rel=\"noopener noreferrer\" href={nextPath}>\n                {item.name}\n              </a>\n            ),\n            key: item.id\n          };\n        })\n    };\n  }, [locale, locales]);\n\n  let additional: MenuItemsType;\n  const additionalItems: MenuItemsType = [\n    github || socialLinks?.github\n      ? {\n          label: (\n            <a rel=\"noopener noreferrer\" href={github || socialLinks?.github} target=\"_blank\">\n              GitHub\n            </a>\n          ),\n          key: 'github'\n        }\n      : null,\n    getLangNode(),\n    ...(getMoreLinksGroup(moreLinks) || [])\n  ];\n\n  if (isMobile) {\n    additional = additionalItems;\n  } else if (responsive === 'crowded') {\n    additional = [\n      {\n        label: <MenuFoldOutlined />,\n        key: 'additional',\n        children: [...additionalItems]\n      }\n    ];\n  }\n\n  const items: MenuItemsType = [...(menuItems ?? []), ...(additional ?? [])];\n  const menuMode = isMobile ? 'inline' : 'horizontal';\n  const style = useStyle();\n\n  return (\n    <Menu\n      items={items}\n      mode={menuMode}\n      css={style.nav}\n      selectedKeys={[activeKey]}\n      disabledOverflow\n    />\n  );\n}\n"]} */")
+  };
+};
+export default function Navigation(_ref) {
+  var _additional;
+  var isMobile = _ref.isMobile,
+    responsive = _ref.responsive;
+  var _useLocation = useLocation(),
+    pathname = _useLocation.pathname,
+    search = _useLocation.search;
+  var _useSiteData = useSiteData(),
+    locales = _useSiteData.locales;
+  var _useAdditionalThemeCo = useAdditionalThemeConfig(),
+    github = _useAdditionalThemeCo.github,
+    socialLinks = _useAdditionalThemeCo.socialLinks;
+
+  // 统一使用 themeConfig.nav，使用 useNavData，当存在自定义 pages 时，会导致 nav 混乱
+  var navList = useNavData();
+  var locale = useLocale();
+  var moreLinks = useLocaleValue('moreLinks');
+  var activeKey = getWithoutLocaleFirstPath(pathname, locale.base);
+  var menuItems = (navList !== null && navList !== void 0 ? navList : []).map(function (navItem) {
+    var _ref2 = navItem || {},
+      title = _ref2.title,
+      link = _ref2.link;
+    var key = getWithoutLocaleFirstPath(link, locale.base);
+    var path = "".concat(link).concat(search);
+    return {
+      key: key,
+      label: isExternalLinks(link) ? ___EmotionJSX("a", {
+        href: path,
+        target: "_blank",
+        rel: "noopener noreferrer"
+      }, title) : ___EmotionJSX(Link, {
+        to: path
+      }, title)
+    };
+  }).filter(Boolean);
+
+  // 获取小屏幕下多语言导航栏节点
+  var getLangNode = useCallback(function () {
+    if (locales.length < 2) {
+      return null;
+    }
+    if (locales.length === 2) {
+      var nextLang = locales.filter(function (item) {
+        return item.id !== locale.id;
+      })[0];
+      var nextPath = getTargetLocalePath({
+        current: locale,
+        target: nextLang
+      });
+      return {
+        label: ___EmotionJSX("a", {
+          rel: "noopener noreferrer",
+          href: nextPath
+        }, nextLang.name),
+        key: nextLang.id
+      };
+    }
+    return {
+      label: ___EmotionJSX("span", null, locale.name),
+      key: 'multi-lang',
+      children: locales.filter(function (item) {
+        return item.id !== locale.id;
+      }).map(function (item) {
+        var nextPath = getTargetLocalePath({
+          current: locale,
+          target: item
+        });
+        return {
+          label: ___EmotionJSX("a", {
+            rel: "noopener noreferrer",
+            href: nextPath
+          }, item.name),
+          key: item.id
+        };
+      })
+    };
+  }, [locale, locales]);
+  var additional;
+  var additionalItems = [github || socialLinks !== null && socialLinks !== void 0 && socialLinks.github ? {
+    label: ___EmotionJSX("a", {
+      rel: "noopener noreferrer",
+      href: github || (socialLinks === null || socialLinks === void 0 ? void 0 : socialLinks.github),
+      target: "_blank"
+    }, "GitHub"),
+    key: 'github'
+  } : null, getLangNode()].concat(_toConsumableArray(getMoreLinksGroup(moreLinks) || []));
+  if (isMobile) {
+    additional = additionalItems;
+  } else if (responsive === 'crowded') {
+    additional = [{
+      label: ___EmotionJSX(MenuFoldOutlined, null),
+      key: 'additional',
+      children: _toConsumableArray(additionalItems)
+    }];
+  }
+  var items = [].concat(_toConsumableArray(menuItems !== null && menuItems !== void 0 ? menuItems : []), _toConsumableArray((_additional = additional) !== null && _additional !== void 0 ? _additional : []));
+  var menuMode = isMobile ? 'inline' : 'horizontal';
+  var style = useStyle();
+  return ___EmotionJSX(Menu, {
+    items: items,
+    mode: menuMode,
+    css: style.nav,
+    selectedKeys: [activeKey],
+    disabledOverflow: true
+  });
+}

package/dist/slots/Header/SwitchBtn.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+export interface LangBtnProps {
+    label1: React.ReactNode;
+    label2: React.ReactNode;
+    tooltip1?: React.ReactNode;
+    tooltip2?: React.ReactNode;
+    value: 1 | 2;
+    pure?: boolean;
+    onClick?: React.MouseEventHandler;
+}
+export default function SwitchBtn({ label1, label2, tooltip1, tooltip2, value, pure, onClick }: LangBtnProps): import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/slots/Header/SwitchBtn.js

@@ -0,0 +1,85 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import { css } from '@emotion/react';
+import { Tooltip } from 'antd';
+import React from 'react';
+import useSiteToken from "../../hooks/useSiteToken";
+import { jsx as ___EmotionJSX } from "@emotion/react";
+var BASE_SIZE = '1.2em';
+var useStyle = function useStyle() {
+  var _useSiteToken = useSiteToken(),
+    token = _useSiteToken.token;
+  var controlHeight = token.controlHeight,
+    motionDurationMid = token.motionDurationMid;
+  return {
+    btn: /*#__PURE__*/css("color:", token.colorText, ";border-color:", token.colorBorder, ";padding:0!important;width:", controlHeight, "px;height:", controlHeight, "px;display:inline-flex;align-items:center;justify-content:center;border:none;background:transparent;border-radius:", token.borderRadius, "px;transition:all ", motionDurationMid, ";cursor:pointer;.btn-inner{transition:all ", motionDurationMid, ";}&:hover{background:", token.colorBgTextHover, ";}img{width:", BASE_SIZE, ";height:", BASE_SIZE, ";}.anticon{font-size:", BASE_SIZE, ";}" + (process.env.NODE_ENV === "production" ? "" : ";label:btn;"), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */")
+  };
+};
+export default function SwitchBtn(_ref) {
+  var label1 = _ref.label1,
+    label2 = _ref.label2,
+    tooltip1 = _ref.tooltip1,
+    tooltip2 = _ref.tooltip2,
+    value = _ref.value,
+    pure = _ref.pure,
+    onClick = _ref.onClick;
+  var _useSiteToken2 = useSiteToken(),
+    token = _useSiteToken2.token;
+  var style = useStyle();
+  var label1Style;
+  var label2Style;
+  var iconStyle = {
+    position: 'absolute',
+    fontSize: BASE_SIZE,
+    lineHeight: 1,
+    border: "1px solid ".concat(token.colorText),
+    color: token.colorText
+  };
+  var fontStyle = {
+    left: '-5%',
+    top: 0,
+    zIndex: 1,
+    background: token.colorText,
+    color: token.colorBgContainer,
+    transformOrigin: '0 0',
+    transform: 'scale(0.7)'
+  };
+  var backStyle = {
+    right: '-5%',
+    bottom: 0,
+    zIndex: 0,
+    transformOrigin: '100% 100%',
+    transform: 'scale(0.5)'
+  };
+  if (value === 1) {
+    label1Style = fontStyle;
+    label2Style = backStyle;
+  } else {
+    label1Style = backStyle;
+    label2Style = fontStyle;
+  }
+  var node = ___EmotionJSX("button", {
+    onClick: onClick,
+    css: [style.btn, process.env.NODE_ENV === "production" ? "" : ";label:node;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"],
+    key: "lang-button",
+    "data-value": value,
+    type: "button"
+  }, ___EmotionJSX("div", {
+    className: "btn-inner"
+  }, pure && (value === 1 ? label1 : label2), !pure && ___EmotionJSX("div", {
+    style: {
+      position: 'relative',
+      width: BASE_SIZE,
+      height: BASE_SIZE
+    }
+  }, ___EmotionJSX("span", {
+    style: _objectSpread(_objectSpread({}, iconStyle), label1Style)
+  }, label1), ___EmotionJSX("span", {
+    style: _objectSpread(_objectSpread({}, iconStyle), label2Style)
+  }, label2))));
+  if (tooltip1 || tooltip2) {
+    node = ___EmotionJSX(Tooltip, {
+      title: value === 1 ? tooltip1 : tooltip2
+    }, node);
+  }
+  return node;
+}

package/dist/slots/Header/index.d.ts

@@ -0,0 +1,4 @@
+import { type FC } from 'react';
+export declare type IResponsive = null | 'narrow' | 'crowded';
+declare const Header: FC;
+export default Header;

package/dist/slots/Header/index.js

@@ -0,0 +1,187 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+/* eslint-disable import/no-unresolved */
+import { MenuOutlined } from '@ant-design/icons';
+import { ClassNames, css } from '@emotion/react';
+import { Col, Popover, Row, Select } from 'antd';
+import classNames from 'classnames';
+import { useLocale, useLocation } from 'dumi';
+import DumiSearchBar from 'dumi/theme-default/slots/SearchBar';
+import React, { useCallback, useContext, useEffect, useState } from 'react';
+import LangSwitch from "dumi/theme/slots/LangSwitch";
+import RtlSwitch from "dumi/theme/slots/RtlSwitch";
+import useAdditionalThemeConfig from "../../hooks/useAdditionalThemeConfig";
+import useSiteToken from "../../hooks/useSiteToken";
+import SiteContext from "dumi/theme/slots/SiteContext";
+import HeaderExtra from "./HeaderExtral";
+import Logo from "./Logo";
+import More from "./More";
+import Navigation from "./Navigation";
+import { jsx as ___EmotionJSX } from "@emotion/react";
+var RESPONSIVE_XS = 1120;
+var RESPONSIVE_SM = 1200;
+var colPropsHome = [{
+  flex: 'none'
+}, {
+  flex: 'auto'
+}];
+var _colProps = [{
+  xxl: 4,
+  xl: 5,
+  lg: 6,
+  md: 6,
+  sm: 24,
+  xs: 24
+}, {
+  xxl: 20,
+  xl: 19,
+  lg: 18,
+  md: 18,
+  sm: 0,
+  xs: 0
+}];
+var useStyle = function useStyle() {
+  var _useSiteToken = useSiteToken(),
+    token = _useSiteToken.token;
+  var searchIconColor = '#ced4d9';
+  return {
+    header: /*#__PURE__*/css("position:sticky;top:0;z-index:99;max-width:100%;background:", token.colorBgContainer, ";box-shadow:", token.boxShadowTertiary, ";border-bottom:", token.lineWidth, "px solid ", token.colorBorderSecondary, ";@media only screen and (max-width: ", token.mobileMaxWidth, "px){text-align:center;}.nav-search-wrapper{display:flex;flex:auto;}.dumi-default-search-bar{border-inline-start:1px solid rgba(0, 0, 0, 0.06);>svg{width:14px;fill:", searchIconColor, ";}>input{height:22px;border:0;&:focus{box-shadow:none;}&::placeholder{color:", searchIconColor, ";}}.dumi-default-search-shortcut{color:", searchIconColor, ";background-color:rgba(150, 150, 150, 0.06);border-color:rgba(100, 100, 100, 0.2);border-radius:4px;}.dumi-default-search-popover{inset-inline-start:11px;inset-inline-end:unset;&::before{inset-inline-start:100px;inset-inline-end:unset;}}}" + (process.env.NODE_ENV === "production" ? "" : ";label:header;"), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["index.tsx"],"names":[],"mappings":"AA4De","file":"index.tsx","sourcesContent":["/* eslint-disable import/no-unresolved */\nimport { MenuOutlined } from '@ant-design/icons';\nimport { ClassNames, css } from '@emotion/react';\nimport { Col, Popover, Row, Select } from 'antd';\nimport classNames from 'classnames';\nimport { useLocale, useLocation } from 'dumi';\nimport DumiSearchBar from 'dumi/theme-default/slots/SearchBar';\nimport React, { useCallback, useContext, useEffect, useState, type FC } from 'react';\nimport LangSwitch from 'dumi/theme/slots/LangSwitch';\nimport RtlSwitch from 'dumi/theme/slots/RtlSwitch';\nimport useAdditionalThemeConfig from '../../hooks/useAdditionalThemeConfig';\nimport useSiteToken from '../../hooks/useSiteToken';\nimport type { SiteContextProps } from '../SiteContext';\nimport SiteContext from '../SiteContext';\nimport HeaderExtra from './HeaderExtral';\nimport Logo from './Logo';\nimport More from './More';\nimport Navigation from './Navigation';\n\ninterface HeaderState {\n  windowWidth: number;\n  menuVisible: boolean;\n}\nexport type IResponsive = null | 'narrow' | 'crowded';\n\nconst RESPONSIVE_XS = 1120;\nconst RESPONSIVE_SM = 1200;\n\nconst colPropsHome = [\n  {\n    flex: 'none'\n  },\n  {\n    flex: 'auto'\n  }\n];\nconst _colProps = [\n  {\n    xxl: 4,\n    xl: 5,\n    lg: 6,\n    md: 6,\n    sm: 24,\n    xs: 24\n  },\n  {\n    xxl: 20,\n    xl: 19,\n    lg: 18,\n    md: 18,\n    sm: 0,\n    xs: 0\n  }\n];\n\nconst useStyle = () => {\n  const { token } = useSiteToken();\n  const searchIconColor = '#ced4d9';\n\n  return {\n    header: css`\n      position: sticky;\n      top: 0;\n      z-index: 99;\n      max-width: 100%;\n      background: ${token.colorBgContainer};\n      box-shadow: ${token.boxShadowTertiary};\n      border-bottom: ${token.lineWidth}px solid ${token.colorBorderSecondary};\n\n      @media only screen and (max-width: ${token.mobileMaxWidth}px) {\n        text-align: center;\n      }\n\n      .nav-search-wrapper {\n        display: flex;\n        flex: auto;\n      }\n\n      .dumi-default-search-bar {\n        border-inline-start: 1px solid rgba(0, 0, 0, 0.06);\n\n        > svg {\n          width: 14px;\n          fill: ${searchIconColor};\n        }\n\n        > input {\n          height: 22px;\n          border: 0;\n\n          &:focus {\n            box-shadow: none;\n          }\n\n          &::placeholder {\n            color: ${searchIconColor};\n          }\n        }\n\n        .dumi-default-search-shortcut {\n          color: ${searchIconColor};\n          background-color: rgba(150, 150, 150, 0.06);\n          border-color: rgba(100, 100, 100, 0.2);\n          border-radius: 4px;\n        }\n\n        .dumi-default-search-popover {\n          inset-inline-start: 11px;\n          inset-inline-end: unset;\n\n          &::before {\n            inset-inline-start: 100px;\n            inset-inline-end: unset;\n          }\n        }\n      }\n    `,\n    menuRow: css`\n      display: flex;\n      align-items: center;\n      margin: 0;\n\n      > * {\n        flex: none;\n        margin: 0 12px 0 0;\n\n        &:last-child {\n          margin-inline-end: 40px;\n        }\n      }\n\n      ${token.antCls}-row-rtl & {\n        > * {\n          &:last-child {\n            margin-right: 12px;\n            margin-left: 40px;\n          }\n        }\n      }\n    `,\n    popoverMenu: {\n      width: 300,\n\n      [`${token.antCls}-popover-inner-content`]: {\n        padding: 0\n      }\n    }\n  };\n};\n\nconst Header: FC = () => {\n  const { isMobile } = useContext<SiteContextProps>(SiteContext);\n  const [headerState, setHeaderState] = useState<HeaderState>({\n    windowWidth: 1400,\n    menuVisible: false\n  });\n  const locale = useLocale();\n  const location = useLocation();\n  const { docVersions } = useAdditionalThemeConfig();\n\n  const onWindowResize = useCallback(() => {\n    setHeaderState((prev) => ({\n      ...prev,\n      windowWidth: window.innerWidth\n    }));\n  }, []);\n  const handleHideMenu = useCallback(() => {\n    setHeaderState((prev) => ({\n      ...prev,\n      menuVisible: false\n    }));\n  }, []);\n  const onMenuVisibleChange = useCallback((visible: boolean) => {\n    setHeaderState((prev) => ({\n      ...prev,\n      menuVisible: visible\n    }));\n  }, []);\n\n  const handleVersionChange = useCallback((url: string) => {\n    window.location.href = url;\n  }, []);\n\n  useEffect(() => {\n    handleHideMenu();\n  }, [location, handleHideMenu]);\n\n  useEffect(() => {\n    onWindowResize();\n    window.addEventListener('resize', onWindowResize);\n    return () => {\n      window.removeEventListener('resize', onWindowResize);\n    };\n  }, [onWindowResize]);\n\n  const localeBase = 'base' in locale ? locale.base : '';\n  const localeSuffix = 'suffix' in locale ? locale.suffix : '';\n  const { pathname } = location;\n\n  const path = pathname.endsWith('/') ? pathname.slice(0, -1) : pathname;\n  const isHome = ['', 'index', `index${localeSuffix}`, localeBase].includes(path);\n\n  const { windowWidth, menuVisible } = headerState;\n  const style = useStyle();\n  const headerClassName = classNames({\n    clearfix: true,\n    'home-header': isHome\n  });\n  let responsive: IResponsive = null;\n\n  if (windowWidth < RESPONSIVE_XS) {\n    responsive = 'crowded';\n  } else if (windowWidth < RESPONSIVE_SM) {\n    responsive = 'narrow';\n  }\n\n  const navigationNode = <Navigation key=\"nav\" isMobile={isMobile} responsive={responsive} />;\n  const versionOptions = Object.keys(docVersions ?? {}).map((version) => ({\n    value: docVersions?.[version],\n    label: version\n  }));\n  let menu: (React.ReactElement | null)[] = [\n    navigationNode,\n    versionOptions.length > 0 ? (\n      <Select\n        key=\"version\"\n        size=\"small\"\n        defaultValue={versionOptions[0]?.value}\n        onChange={handleVersionChange}\n        popupMatchSelectWidth={false}\n        getPopupContainer={(trigger) => trigger.parentNode}\n        options={versionOptions}\n      />\n    ) : null,\n    <More key=\"more\" />,\n    <LangSwitch key={new Date().getTime()} />,\n    <RtlSwitch key=\"direction\" />,\n    <HeaderExtra key=\"header-Extra\" />\n  ];\n  if (windowWidth < RESPONSIVE_XS) {\n    menu = [navigationNode];\n  }\n\n  const colProps = isHome ? colPropsHome : _colProps;\n\n  return (\n    <header css={style.header} className={headerClassName}>\n      {isMobile && (\n        <ClassNames>\n          {({ css: cssFn }) => (\n            <Popover\n              overlayClassName={cssFn(style.popoverMenu)}\n              placement=\"bottomRight\"\n              content={menu}\n              trigger=\"click\"\n              open={menuVisible}\n              arrow\n              onOpenChange={onMenuVisibleChange}\n            >\n              <MenuOutlined className=\"nav-phone-icon\" rev={undefined} />\n            </Popover>\n          )}\n        </ClassNames>\n      )}\n      <Row\n        style={{\n          height: 64\n        }}\n      >\n        <Col {...colProps[0]}>\n          <Logo />\n        </Col>\n        <Col {...colProps[1]} css={style.menuRow}>\n          <div className=\"nav-search-wrapper\">\n            <DumiSearchBar />\n          </div>\n          {!isMobile && menu}\n        </Col>\n      </Row>\n    </header>\n  );\n};\n\nexport default Header;\n"]} */"),
+    menuRow: /*#__PURE__*/css("display:flex;align-items:center;margin:0;>*{flex:none;margin:0 12px 0 0;&:last-child{margin-inline-end:40px;}}", token.antCls, "-row-rtl &{>*{&:last-child{margin-right:12px;margin-left:40px;}}}" + (process.env.NODE_ENV === "production" ? "" : ";label:menuRow;"), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["index.tsx"],"names":[],"mappings":"AAqHgB","file":"index.tsx","sourcesContent":["/* eslint-disable import/no-unresolved */\nimport { MenuOutlined } from '@ant-design/icons';\nimport { ClassNames, css } from '@emotion/react';\nimport { Col, Popover, Row, Select } from 'antd';\nimport classNames from 'classnames';\nimport { useLocale, useLocation } from 'dumi';\nimport DumiSearchBar from 'dumi/theme-default/slots/SearchBar';\nimport React, { useCallback, useContext, useEffect, useState, type FC } from 'react';\nimport LangSwitch from 'dumi/theme/slots/LangSwitch';\nimport RtlSwitch from 'dumi/theme/slots/RtlSwitch';\nimport useAdditionalThemeConfig from '../../hooks/useAdditionalThemeConfig';\nimport useSiteToken from '../../hooks/useSiteToken';\nimport type { SiteContextProps } from '../SiteContext';\nimport SiteContext from '../SiteContext';\nimport HeaderExtra from './HeaderExtral';\nimport Logo from './Logo';\nimport More from './More';\nimport Navigation from './Navigation';\n\ninterface HeaderState {\n  windowWidth: number;\n  menuVisible: boolean;\n}\nexport type IResponsive = null | 'narrow' | 'crowded';\n\nconst RESPONSIVE_XS = 1120;\nconst RESPONSIVE_SM = 1200;\n\nconst colPropsHome = [\n  {\n    flex: 'none'\n  },\n  {\n    flex: 'auto'\n  }\n];\nconst _colProps = [\n  {\n    xxl: 4,\n    xl: 5,\n    lg: 6,\n    md: 6,\n    sm: 24,\n    xs: 24\n  },\n  {\n    xxl: 20,\n    xl: 19,\n    lg: 18,\n    md: 18,\n    sm: 0,\n    xs: 0\n  }\n];\n\nconst useStyle = () => {\n  const { token } = useSiteToken();\n  const searchIconColor = '#ced4d9';\n\n  return {\n    header: css`\n      position: sticky;\n      top: 0;\n      z-index: 99;\n      max-width: 100%;\n      background: ${token.colorBgContainer};\n      box-shadow: ${token.boxShadowTertiary};\n      border-bottom: ${token.lineWidth}px solid ${token.colorBorderSecondary};\n\n      @media only screen and (max-width: ${token.mobileMaxWidth}px) {\n        text-align: center;\n      }\n\n      .nav-search-wrapper {\n        display: flex;\n        flex: auto;\n      }\n\n      .dumi-default-search-bar {\n        border-inline-start: 1px solid rgba(0, 0, 0, 0.06);\n\n        > svg {\n          width: 14px;\n          fill: ${searchIconColor};\n        }\n\n        > input {\n          height: 22px;\n          border: 0;\n\n          &:focus {\n            box-shadow: none;\n          }\n\n          &::placeholder {\n            color: ${searchIconColor};\n          }\n        }\n\n        .dumi-default-search-shortcut {\n          color: ${searchIconColor};\n          background-color: rgba(150, 150, 150, 0.06);\n          border-color: rgba(100, 100, 100, 0.2);\n          border-radius: 4px;\n        }\n\n        .dumi-default-search-popover {\n          inset-inline-start: 11px;\n          inset-inline-end: unset;\n\n          &::before {\n            inset-inline-start: 100px;\n            inset-inline-end: unset;\n          }\n        }\n      }\n    `,\n    menuRow: css`\n      display: flex;\n      align-items: center;\n      margin: 0;\n\n      > * {\n        flex: none;\n        margin: 0 12px 0 0;\n\n        &:last-child {\n          margin-inline-end: 40px;\n        }\n      }\n\n      ${token.antCls}-row-rtl & {\n        > * {\n          &:last-child {\n            margin-right: 12px;\n            margin-left: 40px;\n          }\n        }\n      }\n    `,\n    popoverMenu: {\n      width: 300,\n\n      [`${token.antCls}-popover-inner-content`]: {\n        padding: 0\n      }\n    }\n  };\n};\n\nconst Header: FC = () => {\n  const { isMobile } = useContext<SiteContextProps>(SiteContext);\n  const [headerState, setHeaderState] = useState<HeaderState>({\n    windowWidth: 1400,\n    menuVisible: false\n  });\n  const locale = useLocale();\n  const location = useLocation();\n  const { docVersions } = useAdditionalThemeConfig();\n\n  const onWindowResize = useCallback(() => {\n    setHeaderState((prev) => ({\n      ...prev,\n      windowWidth: window.innerWidth\n    }));\n  }, []);\n  const handleHideMenu = useCallback(() => {\n    setHeaderState((prev) => ({\n      ...prev,\n      menuVisible: false\n    }));\n  }, []);\n  const onMenuVisibleChange = useCallback((visible: boolean) => {\n    setHeaderState((prev) => ({\n      ...prev,\n      menuVisible: visible\n    }));\n  }, []);\n\n  const handleVersionChange = useCallback((url: string) => {\n    window.location.href = url;\n  }, []);\n\n  useEffect(() => {\n    handleHideMenu();\n  }, [location, handleHideMenu]);\n\n  useEffect(() => {\n    onWindowResize();\n    window.addEventListener('resize', onWindowResize);\n    return () => {\n      window.removeEventListener('resize', onWindowResize);\n    };\n  }, [onWindowResize]);\n\n  const localeBase = 'base' in locale ? locale.base : '';\n  const localeSuffix = 'suffix' in locale ? locale.suffix : '';\n  const { pathname } = location;\n\n  const path = pathname.endsWith('/') ? pathname.slice(0, -1) : pathname;\n  const isHome = ['', 'index', `index${localeSuffix}`, localeBase].includes(path);\n\n  const { windowWidth, menuVisible } = headerState;\n  const style = useStyle();\n  const headerClassName = classNames({\n    clearfix: true,\n    'home-header': isHome\n  });\n  let responsive: IResponsive = null;\n\n  if (windowWidth < RESPONSIVE_XS) {\n    responsive = 'crowded';\n  } else if (windowWidth < RESPONSIVE_SM) {\n    responsive = 'narrow';\n  }\n\n  const navigationNode = <Navigation key=\"nav\" isMobile={isMobile} responsive={responsive} />;\n  const versionOptions = Object.keys(docVersions ?? {}).map((version) => ({\n    value: docVersions?.[version],\n    label: version\n  }));\n  let menu: (React.ReactElement | null)[] = [\n    navigationNode,\n    versionOptions.length > 0 ? (\n      <Select\n        key=\"version\"\n        size=\"small\"\n        defaultValue={versionOptions[0]?.value}\n        onChange={handleVersionChange}\n        popupMatchSelectWidth={false}\n        getPopupContainer={(trigger) => trigger.parentNode}\n        options={versionOptions}\n      />\n    ) : null,\n    <More key=\"more\" />,\n    <LangSwitch key={new Date().getTime()} />,\n    <RtlSwitch key=\"direction\" />,\n    <HeaderExtra key=\"header-Extra\" />\n  ];\n  if (windowWidth < RESPONSIVE_XS) {\n    menu = [navigationNode];\n  }\n\n  const colProps = isHome ? colPropsHome : _colProps;\n\n  return (\n    <header css={style.header} className={headerClassName}>\n      {isMobile && (\n        <ClassNames>\n          {({ css: cssFn }) => (\n            <Popover\n              overlayClassName={cssFn(style.popoverMenu)}\n              placement=\"bottomRight\"\n              content={menu}\n              trigger=\"click\"\n              open={menuVisible}\n              arrow\n              onOpenChange={onMenuVisibleChange}\n            >\n              <MenuOutlined className=\"nav-phone-icon\" rev={undefined} />\n            </Popover>\n          )}\n        </ClassNames>\n      )}\n      <Row\n        style={{\n          height: 64\n        }}\n      >\n        <Col {...colProps[0]}>\n          <Logo />\n        </Col>\n        <Col {...colProps[1]} css={style.menuRow}>\n          <div className=\"nav-search-wrapper\">\n            <DumiSearchBar />\n          </div>\n          {!isMobile && menu}\n        </Col>\n      </Row>\n    </header>\n  );\n};\n\nexport default Header;\n"]} */"),
+    popoverMenu: _defineProperty({
+      width: 300
+    }, "".concat(token.antCls, "-popover-inner-content"), {
+      padding: 0
+    })
+  };
+};
+var Header = function Header() {
+  var _versionOptions$;
+  var _useContext = useContext(SiteContext),
+    isMobile = _useContext.isMobile;
+  var _useState = useState({
+      windowWidth: 1400,
+      menuVisible: false
+    }),
+    _useState2 = _slicedToArray(_useState, 2),
+    headerState = _useState2[0],
+    setHeaderState = _useState2[1];
+  var locale = useLocale();
+  var location = useLocation();
+  var _useAdditionalThemeCo = useAdditionalThemeConfig(),
+    docVersions = _useAdditionalThemeCo.docVersions;
+  var onWindowResize = useCallback(function () {
+    setHeaderState(function (prev) {
+      return _objectSpread(_objectSpread({}, prev), {}, {
+        windowWidth: window.innerWidth
+      });
+    });
+  }, []);
+  var handleHideMenu = useCallback(function () {
+    setHeaderState(function (prev) {
+      return _objectSpread(_objectSpread({}, prev), {}, {
+        menuVisible: false
+      });
+    });
+  }, []);
+  var onMenuVisibleChange = useCallback(function (visible) {
+    setHeaderState(function (prev) {
+      return _objectSpread(_objectSpread({}, prev), {}, {
+        menuVisible: visible
+      });
+    });
+  }, []);
+  var handleVersionChange = useCallback(function (url) {
+    window.location.href = url;
+  }, []);
+  useEffect(function () {
+    handleHideMenu();
+  }, [location, handleHideMenu]);
+  useEffect(function () {
+    onWindowResize();
+    window.addEventListener('resize', onWindowResize);
+    return function () {
+      window.removeEventListener('resize', onWindowResize);
+    };
+  }, [onWindowResize]);
+  var localeBase = 'base' in locale ? locale.base : '';
+  var localeSuffix = 'suffix' in locale ? locale.suffix : '';
+  var pathname = location.pathname;
+  var path = pathname.endsWith('/') ? pathname.slice(0, -1) : pathname;
+  var isHome = ['', 'index', "index".concat(localeSuffix), localeBase].includes(path);
+  var windowWidth = headerState.windowWidth,
+    menuVisible = headerState.menuVisible;
+  var style = useStyle();
+  var headerClassName = classNames({
+    clearfix: true,
+    'home-header': isHome
+  });
+  var responsive = null;
+  if (windowWidth < RESPONSIVE_XS) {
+    responsive = 'crowded';
+  } else if (windowWidth < RESPONSIVE_SM) {
+    responsive = 'narrow';
+  }
+  var navigationNode = ___EmotionJSX(Navigation, {
+    key: "nav",
+    isMobile: isMobile,
+    responsive: responsive
+  });
+  var versionOptions = Object.keys(docVersions !== null && docVersions !== void 0 ? docVersions : {}).map(function (version) {
+    return {
+      value: docVersions === null || docVersions === void 0 ? void 0 : docVersions[version],
+      label: version
+    };
+  });
+  var menu = [navigationNode, versionOptions.length > 0 ? ___EmotionJSX(Select, {
+    key: "version",
+    size: "small",
+    defaultValue: (_versionOptions$ = versionOptions[0]) === null || _versionOptions$ === void 0 ? void 0 : _versionOptions$.value,
+    onChange: handleVersionChange,
+    popupMatchSelectWidth: false,
+    getPopupContainer: function getPopupContainer(trigger) {
+      return trigger.parentNode;
+    },
+    options: versionOptions
+  }) : null, ___EmotionJSX(More, {
+    key: "more"
+  }), ___EmotionJSX(LangSwitch, {
+    key: new Date().getTime()
+  }), ___EmotionJSX(RtlSwitch, {
+    key: "direction"
+  }), ___EmotionJSX(HeaderExtra, {
+    key: "header-Extra"
+  })];
+  if (windowWidth < RESPONSIVE_XS) {
+    menu = [navigationNode];
+  }
+  var colProps = isHome ? colPropsHome : _colProps;
+  return ___EmotionJSX("header", {
+    css: style.header,
+    className: headerClassName
+  }, isMobile && ___EmotionJSX(ClassNames, null, function (_ref) {
+    var cssFn = _ref.css;
+    return ___EmotionJSX(Popover, {
+      overlayClassName: cssFn(style.popoverMenu),
+      placement: "bottomRight",
+      content: menu,
+      trigger: "click",
+      open: menuVisible,
+      arrow: true,
+      onOpenChange: onMenuVisibleChange
+    }, ___EmotionJSX(MenuOutlined, {
+      className: "nav-phone-icon",
+      rev: undefined
+    }));
+  }), ___EmotionJSX(Row, {
+    style: {
+      height: 64
+    }
+  }, ___EmotionJSX(Col, colProps[0], ___EmotionJSX(Logo, null)), ___EmotionJSX(Col, _extends({}, colProps[1], {
+    css: style.menuRow
+  }), ___EmotionJSX("div", {
+    className: "nav-search-wrapper"
+  }, ___EmotionJSX(DumiSearchBar, null)), !isMobile && menu)));
+};
+export default Header;

package/dist/slots/LangSwitch/index.d.ts

@@ -0,0 +1,3 @@
+import { type FC } from 'react';
+declare const LangSwitch: FC;
+export default LangSwitch;

package/dist/slots/LangSwitch/index.js

@@ -0,0 +1,84 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+// 多语言切换
+import { Select } from 'antd';
+import { history, useIntl, useLocale, useLocation, useSearchParams, useSiteData } from 'dumi';
+import { useCallback } from 'react';
+import useAdditionalThemeConfig from "../../hooks/useAdditionalThemeConfig";
+import { getTargetLocalePath } from "../../utils";
+import SwitchBtn from "../Header/SwitchBtn";
+import { jsx as ___EmotionJSX } from "@emotion/react";
+var Option = Select.Option;
+var LangSwitch = function LangSwitch() {
+  var _useSearchParams = useSearchParams(),
+    _useSearchParams2 = _slicedToArray(_useSearchParams, 1),
+    searchParams = _useSearchParams2[0];
+  var _useAdditionalThemeCo = useAdditionalThemeConfig(),
+    localesEnhance = _useAdditionalThemeCo.localesEnhance;
+  var _useSiteData = useSiteData(),
+    locales = _useSiteData.locales;
+  var _useIntl = useIntl(),
+    locale = _useIntl.locale;
+  var current = useLocale();
+  var _useLocation = useLocation(),
+    pathname = _useLocation.pathname;
+  var handleLangChange = useCallback(function (lang) {
+    var path = getTargetLocalePath({
+      pathname: pathname,
+      current: current,
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      target: locales.find(function (_ref) {
+        var id = _ref.id;
+        return id === lang;
+      })
+    });
+
+    // remove trailing slash if path is not root
+    if (path.endsWith('/') && path !== '/') {
+      path = path.slice(0, -1);
+    }
+    history.push({
+      pathname: path,
+      search: searchParams.toString()
+    });
+  }, [pathname, current, locales, searchParams]);
+  var onLangChange = useCallback(function () {
+    handleLangChange(locales.filter(function (item) {
+      return item.id !== locale;
+    })[0].id);
+  }, [locale, handleLangChange, locales]);
+  var LangSwitchJSX;
+  // do not render in single language
+  if (locales.length > 2 || !localesEnhance && locales.length > 2) {
+    var langOptions = locales.map(function (lang) {
+      return ___EmotionJSX(Option, {
+        value: lang.id,
+        key: lang.id
+      }, lang.name);
+    });
+    LangSwitchJSX = ___EmotionJSX(Select, {
+      key: "lang",
+      className: "version",
+      size: "small",
+      defaultValue: locale,
+      onChange: handleLangChange,
+      popupMatchSelectWidth: false,
+      getPopupContainer: function getPopupContainer(trigger) {
+        return trigger.parentNode;
+      }
+    }, langOptions);
+  } else if (locales.length === 2 && Array.isArray(localesEnhance) && localesEnhance.length > 1) {
+    // 按 locales 顺序展示
+    var switchValue = locales[0].id === locale ? 1 : 2;
+    LangSwitchJSX = ___EmotionJSX(SwitchBtn, {
+      key: "lang",
+      onClick: onLangChange,
+      value: switchValue,
+      label1: localesEnhance[0].switchPrefix,
+      label2: localesEnhance[1].switchPrefix,
+      tooltip1: "".concat(locales[0].name, " / ").concat(locales[1].name),
+      tooltip2: "".concat(locales[1].name, " / ").concat(locales[0].name)
+    });
+  }
+  return LangSwitchJSX;
+};
+export default LangSwitch;

package/dist/slots/NotFound/index.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+export interface NotFoundProps {
+    router: {
+        push: (pathname: string) => void;
+        replace: (pathname: string) => void;
+    };
+}
+declare const NotFoundPage: React.FC<NotFoundProps>;
+export default NotFoundPage;

package/dist/slots/NotFound/index.js

@@ -0,0 +1,25 @@
+import { HomeOutlined } from '@ant-design/icons';
+import { Button, Result } from 'antd';
+import { FormattedMessage, Link } from 'dumi';
+import React from 'react';
+import { jsx as ___EmotionJSX } from "@emotion/react";
+var NotFoundPage = function NotFoundPage() {
+  return ___EmotionJSX("div", {
+    id: "page-404"
+  }, ___EmotionJSX("section", null, ___EmotionJSX(Result, {
+    status: "404",
+    title: "404",
+    subTitle: ___EmotionJSX(FormattedMessage, {
+      id: "app.not-found.subTitle"
+    }),
+    extra: ___EmotionJSX(Link, {
+      to: "/"
+    }, ___EmotionJSX(Button, {
+      type: "primary",
+      icon: ___EmotionJSX(HomeOutlined, null)
+    }, ' ', ___EmotionJSX(FormattedMessage, {
+      id: "app.not-found.back-home"
+    })))
+  })));
+};
+export default NotFoundPage;

package/dist/slots/RtlSwitch/index.d.ts

@@ -0,0 +1,3 @@
+import { type FC } from 'react';
+declare const RtlSwitch: FC;
+export default RtlSwitch;