@nocobase/plugin-client 0.11.1-alpha.5 → 0.12.0-alpha.2

package/dist/locale/antd/alert/index.js

@@ -0,0 +1,14 @@
+"use strict";
+'use client';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _Alert = _interopRequireDefault(require("./Alert"));
+var _ErrorBoundary = _interopRequireDefault(require("./ErrorBoundary"));
+const Alert = _Alert.default;
+Alert.ErrorBoundary = _ErrorBoundary.default;
+var _default = Alert;
+exports.default = _default;

package/dist/locale/antd/alert/style/index.d.ts

@@ -0,0 +1,13 @@
+import type { FullToken, GenerateStyle } from '../../theme/internal';
+export interface ComponentToken {
+}
+type AlertToken = FullToken<'Alert'> & {
+    alertIconSizeLG: number;
+    alertPaddingHorizontal: number;
+};
+export declare const genBaseStyle: GenerateStyle<AlertToken>;
+export declare const genTypeStyle: GenerateStyle<AlertToken>;
+export declare const genActionStyle: GenerateStyle<AlertToken>;
+export declare const genAlertStyle: GenerateStyle<AlertToken>;
+declare const _default: (prefixCls: string) => import("../../theme/interface").UseComponentStyleResult;
+export default _default;

package/dist/locale/antd/alert/style/index.js

@@ -0,0 +1,192 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.genTypeStyle = exports.genBaseStyle = exports.genAlertStyle = exports.genActionStyle = exports.default = void 0;
+var _style = require("../../style");
+var _internal = require("../../theme/internal");
+const genAlertTypeStyle = (bgColor, borderColor, iconColor, token, alertCls) => ({
+  backgroundColor: bgColor,
+  border: `${token.lineWidth}px ${token.lineType} ${borderColor}`,
+  [`${alertCls}-icon`]: {
+    color: iconColor
+  }
+});
+const genBaseStyle = token => {
+  const {
+    componentCls,
+    motionDurationSlow: duration,
+    marginXS,
+    marginSM,
+    fontSize,
+    fontSizeLG,
+    lineHeight,
+    borderRadiusLG: borderRadius,
+    motionEaseInOutCirc,
+    alertIconSizeLG,
+    colorText,
+    paddingContentVerticalSM,
+    alertPaddingHorizontal,
+    paddingMD,
+    paddingContentHorizontalLG,
+    colorTextHeading
+  } = token;
+  return {
+    [componentCls]: Object.assign(Object.assign({}, (0, _style.resetComponent)(token)), {
+      position: 'relative',
+      display: 'flex',
+      alignItems: 'center',
+      padding: `${paddingContentVerticalSM}px ${alertPaddingHorizontal}px`,
+      wordWrap: 'break-word',
+      borderRadius,
+      [`&${componentCls}-rtl`]: {
+        direction: 'rtl'
+      },
+      [`${componentCls}-content`]: {
+        flex: 1,
+        minWidth: 0
+      },
+      [`${componentCls}-icon`]: {
+        marginInlineEnd: marginXS,
+        lineHeight: 0
+      },
+      [`&-description`]: {
+        display: 'none',
+        fontSize,
+        lineHeight
+      },
+      '&-message': {
+        color: colorText
+      },
+      [`&${componentCls}-motion-leave`]: {
+        overflow: 'hidden',
+        opacity: 1,
+        transition: `max-height ${duration} ${motionEaseInOutCirc}, opacity ${duration} ${motionEaseInOutCirc},
+        padding-top ${duration} ${motionEaseInOutCirc}, padding-bottom ${duration} ${motionEaseInOutCirc},
+        margin-bottom ${duration} ${motionEaseInOutCirc}`
+      },
+      [`&${componentCls}-motion-leave-active`]: {
+        maxHeight: 0,
+        marginBottom: '0 !important',
+        paddingTop: 0,
+        paddingBottom: 0,
+        opacity: 0
+      }
+    }),
+    [`${componentCls}-with-description`]: {
+      alignItems: 'flex-start',
+      paddingInline: paddingContentHorizontalLG,
+      paddingBlock: paddingMD,
+      [`${componentCls}-icon`]: {
+        marginInlineEnd: marginSM,
+        fontSize: alertIconSizeLG,
+        lineHeight: 0
+      },
+      [`${componentCls}-message`]: {
+        display: 'block',
+        marginBottom: marginXS,
+        color: colorTextHeading,
+        fontSize: fontSizeLG
+      },
+      [`${componentCls}-description`]: {
+        display: 'block'
+      }
+    },
+    [`${componentCls}-banner`]: {
+      marginBottom: 0,
+      border: '0 !important',
+      borderRadius: 0
+    }
+  };
+};
+exports.genBaseStyle = genBaseStyle;
+const genTypeStyle = token => {
+  const {
+    componentCls,
+    colorSuccess,
+    colorSuccessBorder,
+    colorSuccessBg,
+    colorWarning,
+    colorWarningBorder,
+    colorWarningBg,
+    colorError,
+    colorErrorBorder,
+    colorErrorBg,
+    colorInfo,
+    colorInfoBorder,
+    colorInfoBg
+  } = token;
+  return {
+    [componentCls]: {
+      '&-success': genAlertTypeStyle(colorSuccessBg, colorSuccessBorder, colorSuccess, token, componentCls),
+      '&-info': genAlertTypeStyle(colorInfoBg, colorInfoBorder, colorInfo, token, componentCls),
+      '&-warning': genAlertTypeStyle(colorWarningBg, colorWarningBorder, colorWarning, token, componentCls),
+      '&-error': Object.assign(Object.assign({}, genAlertTypeStyle(colorErrorBg, colorErrorBorder, colorError, token, componentCls)), {
+        [`${componentCls}-description > pre`]: {
+          margin: 0,
+          padding: 0
+        }
+      })
+    }
+  };
+};
+exports.genTypeStyle = genTypeStyle;
+const genActionStyle = token => {
+  const {
+    componentCls,
+    iconCls,
+    motionDurationMid,
+    marginXS,
+    fontSizeIcon,
+    colorIcon,
+    colorIconHover
+  } = token;
+  return {
+    [componentCls]: {
+      [`&-action`]: {
+        marginInlineStart: marginXS
+      },
+      [`${componentCls}-close-icon`]: {
+        marginInlineStart: marginXS,
+        padding: 0,
+        overflow: 'hidden',
+        fontSize: fontSizeIcon,
+        lineHeight: `${fontSizeIcon}px`,
+        backgroundColor: 'transparent',
+        border: 'none',
+        outline: 'none',
+        cursor: 'pointer',
+        [`${iconCls}-close`]: {
+          color: colorIcon,
+          transition: `color ${motionDurationMid}`,
+          '&:hover': {
+            color: colorIconHover
+          }
+        }
+      },
+      '&-close-text': {
+        color: colorIcon,
+        transition: `color ${motionDurationMid}`,
+        '&:hover': {
+          color: colorIconHover
+        }
+      }
+    }
+  };
+};
+exports.genActionStyle = genActionStyle;
+const genAlertStyle = token => [genBaseStyle(token), genTypeStyle(token), genActionStyle(token)];
+exports.genAlertStyle = genAlertStyle;
+var _default = (0, _internal.genComponentStyleHook)('Alert', token => {
+  const {
+    fontSizeHeading3
+  } = token;
+  const alertToken = (0, _internal.mergeToken)(token, {
+    alertIconSizeLG: fontSizeHeading3,
+    alertPaddingHorizontal: 12 // Fixed value here.
+  });
+
+  return [genAlertStyle(alertToken)];
+});
+exports.default = _default;

package/dist/locale/antd/anchor/Anchor.d.ts

@@ -0,0 +1,58 @@
+import * as React from 'react';
+import type { AnchorLinkBaseProps } from './AnchorLink';
+export interface AnchorLinkItemProps extends AnchorLinkBaseProps {
+    key: React.Key;
+    children?: AnchorLinkItemProps[];
+}
+export type AnchorContainer = HTMLElement | Window;
+export interface AnchorProps {
+    prefixCls?: string;
+    className?: string;
+    rootClassName?: string;
+    style?: React.CSSProperties;
+    /**
+     * @deprecated Please use `items` instead.
+     */
+    children?: React.ReactNode;
+    offsetTop?: number;
+    bounds?: number;
+    affix?: boolean;
+    showInkInFixed?: boolean;
+    getContainer?: () => AnchorContainer;
+    /** Return customize highlight anchor */
+    getCurrentAnchor?: (activeLink: string) => string;
+    onClick?: (e: React.MouseEvent<HTMLElement>, link: {
+        title: React.ReactNode;
+        href: string;
+    }) => void;
+    /** Scroll to target offset value, if none, it's offsetTop prop value or 0. */
+    targetOffset?: number;
+    /** Listening event when scrolling change active link */
+    onChange?: (currentActiveLink: string) => void;
+    items?: AnchorLinkItemProps[];
+    direction?: AnchorDirection;
+    replace?: boolean;
+}
+export interface AnchorState {
+    activeLink: null | string;
+}
+export interface AnchorDefaultProps extends AnchorProps {
+    prefixCls: string;
+    affix: boolean;
+    showInkInFixed: boolean;
+    getContainer: () => AnchorContainer;
+}
+export type AnchorDirection = 'vertical' | 'horizontal';
+export interface AntAnchor {
+    registerLink: (link: string) => void;
+    unregisterLink: (link: string) => void;
+    activeLink: string | null;
+    scrollTo: (link: string) => void;
+    onClick?: (e: React.MouseEvent<HTMLAnchorElement, MouseEvent>, link: {
+        title: React.ReactNode;
+        href: string;
+    }) => void;
+    direction: AnchorDirection;
+}
+declare const Anchor: React.FC<AnchorProps>;
+export default Anchor;

package/dist/locale/antd/anchor/Anchor.js

@@ -0,0 +1,261 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _classnames = _interopRequireDefault(require("classnames"));
+var _useEvent = _interopRequireDefault(require("rc-util/lib/hooks/useEvent"));
+var React = _interopRequireWildcard(require("react"));
+var _scrollIntoViewIfNeeded = _interopRequireDefault(require("scroll-into-view-if-needed"));
+var _getScroll = _interopRequireDefault(require("../_util/getScroll"));
+var _scrollTo = _interopRequireDefault(require("../_util/scrollTo"));
+var _warning = _interopRequireDefault(require("../_util/warning"));
+var _affix = _interopRequireDefault(require("../affix"));
+var _configProvider = require("../config-provider");
+var _AnchorLink = _interopRequireDefault(require("./AnchorLink"));
+var _context = _interopRequireDefault(require("./context"));
+var _style = _interopRequireDefault(require("./style"));
+function getDefaultContainer() {
+  return window;
+}
+function getOffsetTop(element, container) {
+  if (!element.getClientRects().length) {
+    return 0;
+  }
+  const rect = element.getBoundingClientRect();
+  if (rect.width || rect.height) {
+    if (container === window) {
+      container = element.ownerDocument.documentElement;
+      return rect.top - container.clientTop;
+    }
+    return rect.top - container.getBoundingClientRect().top;
+  }
+  return rect.top;
+}
+const sharpMatcherRegex = /#([\S ]+)$/;
+const AnchorContent = props => {
+  var _a;
+  const {
+    rootClassName,
+    anchorPrefixCls: prefixCls,
+    className,
+    style,
+    offsetTop,
+    affix = true,
+    showInkInFixed = false,
+    children,
+    items,
+    direction: anchorDirection = 'vertical',
+    bounds,
+    targetOffset,
+    onClick,
+    onChange,
+    getContainer,
+    getCurrentAnchor,
+    replace
+  } = props;
+  // =================== Warning =====================
+  if (process.env.NODE_ENV !== 'production') {
+    process.env.NODE_ENV !== "production" ? (0, _warning.default)(!children, 'Anchor', '`Anchor children` is deprecated. Please use `items` instead.') : void 0;
+  }
+  if (process.env.NODE_ENV !== 'production') {
+    process.env.NODE_ENV !== "production" ? (0, _warning.default)(!(anchorDirection === 'horizontal' && (items === null || items === void 0 ? void 0 : items.some(n => 'children' in n))), 'Anchor', '`Anchor items#children` is not supported when `Anchor` direction is horizontal.') : void 0;
+  }
+  const [links, setLinks] = React.useState([]);
+  const [activeLink, setActiveLink] = React.useState(null);
+  const activeLinkRef = React.useRef(activeLink);
+  const wrapperRef = React.useRef(null);
+  const spanLinkNode = React.useRef(null);
+  const animating = React.useRef(false);
+  const {
+    direction,
+    getTargetContainer,
+    anchor
+  } = React.useContext(_configProvider.ConfigContext);
+  const getCurrentContainer = (_a = getContainer !== null && getContainer !== void 0 ? getContainer : getTargetContainer) !== null && _a !== void 0 ? _a : getDefaultContainer;
+  const dependencyListItem = JSON.stringify(links);
+  const registerLink = (0, _useEvent.default)(link => {
+    if (!links.includes(link)) {
+      setLinks(prev => [].concat((0, _toConsumableArray2.default)(prev), [link]));
+    }
+  });
+  const unregisterLink = (0, _useEvent.default)(link => {
+    if (links.includes(link)) {
+      setLinks(prev => prev.filter(i => i !== link));
+    }
+  });
+  const updateInk = () => {
+    var _a;
+    const linkNode = (_a = wrapperRef.current) === null || _a === void 0 ? void 0 : _a.querySelector(`.${prefixCls}-link-title-active`);
+    if (linkNode && spanLinkNode.current) {
+      const {
+        style: inkStyle
+      } = spanLinkNode.current;
+      const horizontalAnchor = anchorDirection === 'horizontal';
+      inkStyle.top = horizontalAnchor ? '' : `${linkNode.offsetTop + linkNode.clientHeight / 2}px`;
+      inkStyle.height = horizontalAnchor ? '' : `${linkNode.clientHeight}px`;
+      inkStyle.left = horizontalAnchor ? `${linkNode.offsetLeft}px` : '';
+      inkStyle.width = horizontalAnchor ? `${linkNode.clientWidth}px` : '';
+      if (horizontalAnchor) {
+        (0, _scrollIntoViewIfNeeded.default)(linkNode, {
+          scrollMode: 'if-needed',
+          block: 'nearest'
+        });
+      }
+    }
+  };
+  const getInternalCurrentAnchor = function (_links) {
+    let _offsetTop = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    let _bounds = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 5;
+    const linkSections = [];
+    const container = getCurrentContainer();
+    _links.forEach(link => {
+      const sharpLinkMatch = sharpMatcherRegex.exec(link === null || link === void 0 ? void 0 : link.toString());
+      if (!sharpLinkMatch) {
+        return;
+      }
+      const target = document.getElementById(sharpLinkMatch[1]);
+      if (target) {
+        const top = getOffsetTop(target, container);
+        if (top < _offsetTop + _bounds) {
+          linkSections.push({
+            link,
+            top
+          });
+        }
+      }
+    });
+    if (linkSections.length) {
+      const maxSection = linkSections.reduce((prev, curr) => curr.top > prev.top ? curr : prev);
+      return maxSection.link;
+    }
+    return '';
+  };
+  const setCurrentActiveLink = (0, _useEvent.default)(link => {
+    if (activeLinkRef.current === link) {
+      return;
+    }
+    // https://github.com/ant-design/ant-design/issues/30584
+    const newLink = typeof getCurrentAnchor === 'function' ? getCurrentAnchor(link) : link;
+    setActiveLink(newLink);
+    activeLinkRef.current = newLink;
+    // onChange should respect the original link (which may caused by
+    // window scroll or user click), not the new link
+    onChange === null || onChange === void 0 ? void 0 : onChange(link);
+  });
+  const handleScroll = React.useCallback(() => {
+    if (animating.current) {
+      return;
+    }
+    if (typeof getCurrentAnchor === 'function') {
+      return;
+    }
+    const currentActiveLink = getInternalCurrentAnchor(links, targetOffset !== undefined ? targetOffset : offsetTop || 0, bounds);
+    setCurrentActiveLink(currentActiveLink);
+  }, [dependencyListItem, targetOffset, offsetTop]);
+  const handleScrollTo = React.useCallback(link => {
+    setCurrentActiveLink(link);
+    const sharpLinkMatch = sharpMatcherRegex.exec(link);
+    if (!sharpLinkMatch) {
+      return;
+    }
+    const targetElement = document.getElementById(sharpLinkMatch[1]);
+    if (!targetElement) {
+      return;
+    }
+    const container = getCurrentContainer();
+    const scrollTop = (0, _getScroll.default)(container, true);
+    const eleOffsetTop = getOffsetTop(targetElement, container);
+    let y = scrollTop + eleOffsetTop;
+    y -= targetOffset !== undefined ? targetOffset : offsetTop || 0;
+    animating.current = true;
+    (0, _scrollTo.default)(y, {
+      getContainer: getCurrentContainer,
+      callback() {
+        animating.current = false;
+      }
+    });
+  }, [targetOffset, offsetTop]);
+  const wrapperClass = (0, _classnames.default)(rootClassName, `${prefixCls}-wrapper`, {
+    [`${prefixCls}-wrapper-horizontal`]: anchorDirection === 'horizontal',
+    [`${prefixCls}-rtl`]: direction === 'rtl'
+  }, className, anchor === null || anchor === void 0 ? void 0 : anchor.className);
+  const anchorClass = (0, _classnames.default)(prefixCls, {
+    [`${prefixCls}-fixed`]: !affix && !showInkInFixed
+  });
+  const inkClass = (0, _classnames.default)(`${prefixCls}-ink`, {
+    [`${prefixCls}-ink-visible`]: activeLink
+  });
+  const wrapperStyle = Object.assign(Object.assign({
+    maxHeight: offsetTop ? `calc(100vh - ${offsetTop}px)` : '100vh'
+  }, anchor === null || anchor === void 0 ? void 0 : anchor.style), style);
+  const createNestedLink = options => Array.isArray(options) ? options.map(item => /*#__PURE__*/React.createElement(_AnchorLink.default, Object.assign({
+    replace: replace
+  }, item, {
+    key: item.key
+  }), anchorDirection === 'vertical' && createNestedLink(item.children))) : null;
+  const anchorContent = /*#__PURE__*/React.createElement("div", {
+    ref: wrapperRef,
+    className: wrapperClass,
+    style: wrapperStyle
+  }, /*#__PURE__*/React.createElement("div", {
+    className: anchorClass
+  }, /*#__PURE__*/React.createElement("span", {
+    className: inkClass,
+    ref: spanLinkNode
+  }), 'items' in props ? createNestedLink(items) : children));
+  React.useEffect(() => {
+    const scrollContainer = getCurrentContainer();
+    handleScroll();
+    scrollContainer === null || scrollContainer === void 0 ? void 0 : scrollContainer.addEventListener('scroll', handleScroll);
+    return () => {
+      scrollContainer === null || scrollContainer === void 0 ? void 0 : scrollContainer.removeEventListener('scroll', handleScroll);
+    };
+  }, [dependencyListItem]);
+  React.useEffect(() => {
+    if (typeof getCurrentAnchor === 'function') {
+      setCurrentActiveLink(getCurrentAnchor(activeLinkRef.current || ''));
+    }
+  }, [getCurrentAnchor]);
+  React.useEffect(() => {
+    updateInk();
+  }, [anchorDirection, getCurrentAnchor, dependencyListItem, activeLink]);
+  const memoizedContextValue = React.useMemo(() => ({
+    registerLink,
+    unregisterLink,
+    scrollTo: handleScrollTo,
+    activeLink,
+    onClick,
+    direction: anchorDirection
+  }), [activeLink, onClick, handleScrollTo, anchorDirection]);
+  return /*#__PURE__*/React.createElement(_context.default.Provider, {
+    value: memoizedContextValue
+  }, affix ? /*#__PURE__*/React.createElement(_affix.default, {
+    offsetTop: offsetTop,
+    target: getCurrentContainer
+  }, anchorContent) : anchorContent);
+};
+const Anchor = props => {
+  const {
+    prefixCls: customizePrefixCls,
+    rootClassName
+  } = props;
+  const {
+    getPrefixCls
+  } = React.useContext(_configProvider.ConfigContext);
+  const anchorPrefixCls = getPrefixCls('anchor', customizePrefixCls);
+  const [wrapSSR, hashId] = (0, _style.default)(anchorPrefixCls);
+  return wrapSSR( /*#__PURE__*/React.createElement(AnchorContent, Object.assign({}, props, {
+    rootClassName: (0, _classnames.default)(hashId, rootClassName),
+    anchorPrefixCls: anchorPrefixCls
+  })));
+};
+if (process.env.NODE_ENV !== 'production') {
+  Anchor.displayName = 'Anchor';
+}
+var _default = Anchor;
+exports.default = _default;

package/dist/locale/antd/anchor/AnchorLink.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+export interface AnchorLinkBaseProps {
+    prefixCls?: string;
+    href: string;
+    target?: string;
+    title: React.ReactNode;
+    className?: string;
+    replace?: boolean;
+}
+export interface AnchorLinkProps extends AnchorLinkBaseProps {
+    children?: React.ReactNode;
+}
+declare const AnchorLink: React.FC<AnchorLinkProps>;
+export default AnchorLink;

package/dist/locale/antd/anchor/AnchorLink.js

@@ -0,0 +1,76 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _classnames = _interopRequireDefault(require("classnames"));
+var React = _interopRequireWildcard(require("react"));
+var _warning = _interopRequireDefault(require("../_util/warning"));
+var _configProvider = require("../config-provider");
+var _context = _interopRequireDefault(require("./context"));
+const AnchorLink = props => {
+  const {
+    href,
+    title,
+    prefixCls: customizePrefixCls,
+    children,
+    className,
+    target,
+    replace
+  } = props;
+  const context = React.useContext(_context.default);
+  const {
+    registerLink,
+    unregisterLink,
+    scrollTo,
+    onClick,
+    activeLink,
+    direction
+  } = context || {};
+  React.useEffect(() => {
+    registerLink === null || registerLink === void 0 ? void 0 : registerLink(href);
+    return () => {
+      unregisterLink === null || unregisterLink === void 0 ? void 0 : unregisterLink(href);
+    };
+  }, [href]);
+  const handleClick = e => {
+    if (replace) {
+      e.preventDefault();
+      window.location.replace(href);
+    }
+    onClick === null || onClick === void 0 ? void 0 : onClick(e, {
+      title,
+      href
+    });
+    scrollTo === null || scrollTo === void 0 ? void 0 : scrollTo(href);
+  };
+  // =================== Warning =====================
+  if (process.env.NODE_ENV !== 'production') {
+    process.env.NODE_ENV !== "production" ? (0, _warning.default)(!children || direction !== 'horizontal', 'Anchor.Link', '`Anchor.Link children` is not supported when `Anchor` direction is horizontal') : void 0;
+  }
+  const {
+    getPrefixCls
+  } = React.useContext(_configProvider.ConfigContext);
+  const prefixCls = getPrefixCls('anchor', customizePrefixCls);
+  const active = activeLink === href;
+  const wrapperClassName = (0, _classnames.default)(`${prefixCls}-link`, className, {
+    [`${prefixCls}-link-active`]: active
+  });
+  const titleClassName = (0, _classnames.default)(`${prefixCls}-link-title`, {
+    [`${prefixCls}-link-title-active`]: active
+  });
+  return /*#__PURE__*/React.createElement("div", {
+    className: wrapperClassName
+  }, /*#__PURE__*/React.createElement("a", {
+    className: titleClassName,
+    href: href,
+    title: typeof title === 'string' ? title : '',
+    target: target,
+    onClick: handleClick
+  }, title), direction !== 'horizontal' ? children : null);
+};
+var _default = AnchorLink;
+exports.default = _default;

package/dist/locale/antd/anchor/context.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import type { AntAnchor } from './Anchor';
+declare const AnchorContext: React.Context<AntAnchor | undefined>;
+export default AnchorContext;

package/dist/locale/antd/anchor/context.js

@@ -0,0 +1,11 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var React = _interopRequireWildcard(require("react"));
+const AnchorContext = /*#__PURE__*/React.createContext(undefined);
+var _default = AnchorContext;
+exports.default = _default;

package/dist/locale/antd/anchor/index.d.ts

@@ -0,0 +1,10 @@
+import InternalAnchor from './Anchor';
+import AnchorLink from './AnchorLink';
+export type { AnchorProps } from './Anchor';
+export type { AnchorLinkProps } from './AnchorLink';
+type InternalAnchorType = typeof InternalAnchor;
+type CompoundedComponent = InternalAnchorType & {
+    Link: typeof AnchorLink;
+};
+declare const Anchor: CompoundedComponent;
+export default Anchor;

package/dist/locale/antd/anchor/index.js

@@ -0,0 +1,14 @@
+"use strict";
+'use client';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _Anchor = _interopRequireDefault(require("./Anchor"));
+var _AnchorLink = _interopRequireDefault(require("./AnchorLink"));
+const Anchor = _Anchor.default;
+Anchor.Link = _AnchorLink.default;
+var _default = Anchor;
+exports.default = _default;

package/dist/locale/antd/anchor/style/index.d.ts

@@ -0,0 +1,14 @@
+export interface ComponentToken {
+    /**
+     * @desc 链接横向内间距
+     * @descEN Link horizontal padding
+     */
+    linkPaddingBlock: number;
+    /**
+     * @desc 链接纵向内间距
+     * @descEN Link vertical padding
+     */
+    linkPaddingInlineStart: number;
+}
+declare const _default: (prefixCls: string) => import("../../theme/interface").UseComponentStyleResult;
+export default _default;