doui-react 1.0.0

package/lib/portal/index.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _component = require("./component");
+Object.keys(_component).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _component[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _component[key];
+    }
+  });
+});
+var _type = require("./type");
+Object.keys(_type).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _type[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _type[key];
+    }
+  });
+});

package/lib/portal/type/index.d.ts

@@ -0,0 +1,13 @@
+import { FunctionReturn } from "../../api";
+import { ReactNode } from 'react';
+type Container = Element | string | null | undefined;
+export interface PortalProps {
+    children: ReactNode;
+    /**
+     * @description 渲染位置
+     * @default document.body
+     * @replaceAll string | Element
+     */
+    container?: Container | ((current: HTMLElement) => FunctionReturn<Container>);
+}
+export {};

package/lib/portal/type/index.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/radio/component/abstract-box.d.ts

@@ -0,0 +1,380 @@
+/// <reference types="react" />
+import { BaseBoxProps } from "..";
+import type { SerializedStyles } from '@emotion/utils';
+import { CheckboxChangeEvent } from 'antd/lib/checkbox/Checkbox';
+export declare function useAbstractBox({ refs, boxTooltip, value, onChange, inGroup, ...props }: BaseBoxProps): {
+    highlightTextProps: Partial<BaseBoxProps>;
+    tooltipProps: {
+        title: import("react").ReactNode | import("antd/lib/tooltip").RenderFunction;
+        overlay?: import("react").ReactNode | import("antd/lib/tooltip").RenderFunction;
+        style?: import("react").CSSProperties | undefined;
+        className?: string | undefined;
+        color?: string | undefined;
+        placement?: import("antd/lib/tooltip").TooltipPlacement | undefined;
+        builtinPlacements?: import("rc-trigger").BuildInPlacements | undefined;
+        openClassName?: string | undefined;
+        arrowPointAtCenter?: boolean | undefined;
+        autoAdjustOverflow?: boolean | import("antd/lib/tooltip").AdjustOverflow | undefined;
+        getPopupContainer?: ((triggerNode: HTMLElement) => HTMLElement) | undefined;
+        children?: import("react").ReactNode;
+        visible?: boolean | undefined;
+        open?: boolean | undefined;
+        defaultVisible?: boolean | undefined;
+        defaultOpen?: boolean | undefined;
+        onVisibleChange?: ((visible: boolean) => void) | undefined;
+        onOpenChange?: ((visible: boolean) => void) | undefined;
+        afterVisibleChange?: ((visible: boolean) => void) | undefined;
+        afterOpenChange?: ((visible: boolean) => void) | undefined;
+        zIndex?: number | undefined;
+        animation?: string | undefined;
+        motion?: import("rc-motion").CSSMotionProps | undefined;
+        id?: string | undefined;
+        prefixCls?: string | undefined;
+        onPopupAlign?: ((element: HTMLElement, align: import("rc-trigger/lib/interface").AlignType) => void) | undefined;
+        trigger?: string | string[] | undefined;
+        transitionName?: string | undefined;
+        overlayStyle?: import("react").CSSProperties | undefined;
+        overlayClassName?: string | undefined;
+        mouseEnterDelay?: number | undefined;
+        mouseLeaveDelay?: number | undefined;
+        getTooltipContainer?: ((node: HTMLElement) => HTMLElement) | undefined;
+        destroyTooltipOnHide?: boolean | {
+            keepParent?: boolean | undefined;
+        } | undefined;
+        align: import("rc-trigger/lib/interface").AlignType;
+        showArrow?: boolean | undefined;
+        arrowContent?: import("react").ReactNode;
+        popupVisible?: boolean | undefined;
+        overlayInnerStyle?: import("react").CSSProperties | undefined;
+    } | {
+        title?: import("react").ReactNode | import("antd/lib/tooltip").RenderFunction;
+        overlay?: import("react").ReactNode | import("antd/lib/tooltip").RenderFunction;
+        style?: import("react").CSSProperties | undefined;
+        className?: string | undefined;
+        color?: string | undefined;
+        placement?: import("antd/lib/tooltip").TooltipPlacement | undefined;
+        builtinPlacements?: import("rc-trigger").BuildInPlacements | undefined;
+        openClassName?: string | undefined;
+        arrowPointAtCenter?: boolean | undefined;
+        autoAdjustOverflow?: boolean | import("antd/lib/tooltip").AdjustOverflow | undefined;
+        getPopupContainer?: ((triggerNode: HTMLElement) => HTMLElement) | undefined;
+        children?: import("react").ReactNode;
+        visible?: boolean | undefined;
+        open?: boolean | undefined;
+        defaultVisible?: boolean | undefined;
+        defaultOpen?: boolean | undefined;
+        onVisibleChange?: ((visible: boolean) => void) | undefined;
+        onOpenChange?: ((visible: boolean) => void) | undefined;
+        afterVisibleChange?: ((visible: boolean) => void) | undefined;
+        afterOpenChange?: ((visible: boolean) => void) | undefined;
+        zIndex?: number | undefined;
+        animation?: string | undefined;
+        motion?: import("rc-motion").CSSMotionProps | undefined;
+        id?: string | undefined;
+        prefixCls?: string | undefined;
+        onPopupAlign?: ((element: HTMLElement, align: import("rc-trigger/lib/interface").AlignType) => void) | undefined;
+        trigger?: string | string[] | undefined;
+        transitionName?: string | undefined;
+        overlayStyle?: import("react").CSSProperties | undefined;
+        overlayClassName?: string | undefined;
+        mouseEnterDelay?: number | undefined;
+        mouseLeaveDelay?: number | undefined;
+        getTooltipContainer?: ((node: HTMLElement) => HTMLElement) | undefined;
+        destroyTooltipOnHide?: boolean | {
+            keepParent?: boolean | undefined;
+        } | undefined;
+        align: import("rc-trigger/lib/interface").AlignType;
+        showArrow?: boolean | undefined;
+        arrowContent?: import("react").ReactNode;
+        popupVisible?: boolean | undefined;
+        overlayInnerStyle?: import("react").CSSProperties | undefined;
+    };
+    boxProps: {
+        onChange(e: CheckboxChangeEvent): void;
+        children?: import("react").ReactNode;
+        text?: import("react").ReactNode;
+        search?: string | undefined;
+        value?: any;
+        boxTooltip?: import("react").ReactNode | import("antd").TooltipProps;
+        inGroup?: boolean | undefined;
+        style?: import("react").CSSProperties | undefined;
+        type?: string | undefined;
+        className?: string | undefined;
+        onClick?: import("react").MouseEventHandler<HTMLElement> | undefined;
+        defaultChecked?: boolean | undefined;
+        autoFocus?: boolean | undefined;
+        id?: string | undefined;
+        tabIndex?: number | undefined;
+        onKeyDown?: import("react").KeyboardEventHandler<HTMLElement> | undefined;
+        onKeyPress?: import("react").KeyboardEventHandler<HTMLElement> | undefined;
+        onMouseEnter?: import("react").MouseEventHandler<HTMLElement> | undefined;
+        onMouseLeave?: import("react").MouseEventHandler<HTMLElement> | undefined;
+        disabled?: boolean | undefined;
+        name?: string | undefined;
+        prefixCls?: string | undefined;
+        checked?: boolean | undefined;
+        indeterminate?: boolean | undefined;
+        skipGroup?: boolean | undefined;
+        rows?: number | false | undefined;
+        tooltip?: import("react").ReactNode | import("antd").TooltipProps;
+        autoShowTooltip?: boolean | undefined;
+        slot?: string | undefined;
+        title?: string | undefined;
+        accessKey?: string | undefined;
+        color?: string | undefined;
+        content?: string | undefined;
+        direction?: import("antd/lib/config-provider").DirectionType;
+        translate?: "yes" | "no" | undefined;
+        defaultValue?: string | number | readonly string[] | undefined;
+        suppressContentEditableWarning?: boolean | undefined;
+        suppressHydrationWarning?: boolean | undefined;
+        autoCapitalize?: "none" | (string & {}) | "off" | "on" | "sentences" | "words" | "characters" | undefined;
+        contentEditable?: (boolean | "true" | "false") | "inherit" | undefined;
+        contextMenu?: string | undefined;
+        dir?: string | undefined;
+        draggable?: (boolean | "true" | "false") | undefined;
+        enterKeyHint?: "search" | "done" | "enter" | "go" | "next" | "previous" | "send" | undefined;
+        hidden?: boolean | undefined;
+        lang?: string | undefined;
+        nonce?: string | undefined;
+        placeholder?: string | undefined;
+        spellCheck?: (boolean | "true" | "false") | undefined;
+        radioGroup?: string | undefined;
+        role?: import("react").AriaRole | undefined;
+        about?: string | undefined;
+        datatype?: string | undefined;
+        inlist?: any;
+        prefix?: string | undefined;
+        property?: string | undefined;
+        rel?: string | undefined;
+        resource?: string | undefined;
+        rev?: string | undefined;
+        typeof?: string | undefined;
+        vocab?: string | undefined;
+        autoCorrect?: string | undefined;
+        autoSave?: string | undefined;
+        itemProp?: string | undefined;
+        itemScope?: boolean | undefined;
+        itemType?: string | undefined;
+        itemID?: string | undefined;
+        itemRef?: string | undefined;
+        results?: number | undefined;
+        security?: string | undefined;
+        unselectable?: "off" | "on" | undefined;
+        inputMode?: "search" | "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | undefined;
+        is?: string | undefined;
+        "aria-activedescendant"?: string | undefined;
+        "aria-atomic"?: (boolean | "true" | "false") | undefined;
+        "aria-autocomplete"?: "none" | "list" | "inline" | "both" | undefined;
+        "aria-busy"?: (boolean | "true" | "false") | undefined;
+        "aria-checked"?: boolean | "true" | "false" | "mixed" | undefined;
+        "aria-colcount"?: number | undefined;
+        "aria-colindex"?: number | undefined;
+        "aria-colspan"?: number | undefined;
+        "aria-controls"?: string | undefined;
+        "aria-current"?: boolean | "time" | "page" | "true" | "false" | "step" | "location" | "date" | undefined;
+        "aria-describedby"?: string | undefined;
+        "aria-details"?: string | undefined;
+        "aria-disabled"?: (boolean | "true" | "false") | undefined;
+        "aria-dropeffect"?: "none" | "link" | "copy" | "execute" | "move" | "popup" | undefined;
+        "aria-errormessage"?: string | undefined;
+        "aria-expanded"?: (boolean | "true" | "false") | undefined;
+        "aria-flowto"?: string | undefined;
+        "aria-grabbed"?: (boolean | "true" | "false") | undefined;
+        "aria-haspopup"?: boolean | "dialog" | "menu" | "grid" | "true" | "false" | "listbox" | "tree" | undefined;
+        "aria-hidden"?: (boolean | "true" | "false") | undefined;
+        "aria-invalid"?: boolean | "true" | "false" | "grammar" | "spelling" | undefined;
+        "aria-keyshortcuts"?: string | undefined;
+        "aria-label"?: string | undefined;
+        "aria-labelledby"?: string | undefined;
+        "aria-level"?: number | undefined;
+        "aria-live"?: "off" | "assertive" | "polite" | undefined;
+        "aria-modal"?: (boolean | "true" | "false") | undefined;
+        "aria-multiline"?: (boolean | "true" | "false") | undefined;
+        "aria-multiselectable"?: (boolean | "true" | "false") | undefined;
+        "aria-orientation"?: "vertical" | "horizontal" | undefined;
+        "aria-owns"?: string | undefined;
+        "aria-placeholder"?: string | undefined;
+        "aria-posinset"?: number | undefined;
+        "aria-pressed"?: boolean | "true" | "false" | "mixed" | undefined;
+        "aria-readonly"?: (boolean | "true" | "false") | undefined;
+        "aria-relevant"?: "text" | "all" | "additions" | "additions removals" | "additions text" | "removals" | "removals additions" | "removals text" | "text additions" | "text removals" | undefined;
+        "aria-required"?: (boolean | "true" | "false") | undefined;
+        "aria-roledescription"?: string | undefined;
+        "aria-rowcount"?: number | undefined;
+        "aria-rowindex"?: number | undefined;
+        "aria-rowspan"?: number | undefined;
+        "aria-selected"?: (boolean | "true" | "false") | undefined;
+        "aria-setsize"?: number | undefined;
+        "aria-sort"?: "none" | "ascending" | "descending" | "other" | undefined;
+        "aria-valuemax"?: number | undefined;
+        "aria-valuemin"?: number | undefined;
+        "aria-valuenow"?: number | undefined;
+        "aria-valuetext"?: string | undefined;
+        dangerouslySetInnerHTML?: {
+            __html: string | TrustedHTML;
+        } | undefined;
+        onCopy?: import("react").ClipboardEventHandler<HTMLElement> | undefined;
+        onCopyCapture?: import("react").ClipboardEventHandler<HTMLElement> | undefined;
+        onCut?: import("react").ClipboardEventHandler<HTMLElement> | undefined;
+        onCutCapture?: import("react").ClipboardEventHandler<HTMLElement> | undefined;
+        onPaste?: import("react").ClipboardEventHandler<HTMLElement> | undefined;
+        onPasteCapture?: import("react").ClipboardEventHandler<HTMLElement> | undefined;
+        onCompositionEnd?: import("react").CompositionEventHandler<HTMLElement> | undefined;
+        onCompositionEndCapture?: import("react").CompositionEventHandler<HTMLElement> | undefined;
+        onCompositionStart?: import("react").CompositionEventHandler<HTMLElement> | undefined;
+        onCompositionStartCapture?: import("react").CompositionEventHandler<HTMLElement> | undefined;
+        onCompositionUpdate?: import("react").CompositionEventHandler<HTMLElement> | undefined;
+        onCompositionUpdateCapture?: import("react").CompositionEventHandler<HTMLElement> | undefined;
+        onFocus?: import("react").FocusEventHandler<HTMLElement> | undefined;
+        onFocusCapture?: import("react").FocusEventHandler<HTMLElement> | undefined;
+        onBlur?: import("react").FocusEventHandler<HTMLElement> | undefined;
+        onBlurCapture?: import("react").FocusEventHandler<HTMLElement> | undefined;
+        onChangeCapture?: import("react").FormEventHandler<HTMLElement> | undefined;
+        onBeforeInput?: import("react").FormEventHandler<HTMLElement> | undefined;
+        onBeforeInputCapture?: import("react").FormEventHandler<HTMLElement> | undefined;
+        onInput?: import("react").FormEventHandler<HTMLElement> | undefined;
+        onInputCapture?: import("react").FormEventHandler<HTMLElement> | undefined;
+        onReset?: import("react").FormEventHandler<HTMLElement> | undefined;
+        onResetCapture?: import("react").FormEventHandler<HTMLElement> | undefined;
+        onSubmit?: import("react").FormEventHandler<HTMLElement> | undefined;
+        onSubmitCapture?: import("react").FormEventHandler<HTMLElement> | undefined;
+        onInvalid?: import("react").FormEventHandler<HTMLElement> | undefined;
+        onInvalidCapture?: import("react").FormEventHandler<HTMLElement> | undefined;
+        onLoad?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onLoadCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onError?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onErrorCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onKeyDownCapture?: import("react").KeyboardEventHandler<HTMLElement> | undefined;
+        onKeyPressCapture?: import("react").KeyboardEventHandler<HTMLElement> | undefined;
+        onKeyUp?: import("react").KeyboardEventHandler<HTMLElement> | undefined;
+        onKeyUpCapture?: import("react").KeyboardEventHandler<HTMLElement> | undefined;
+        onAbort?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onAbortCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onCanPlay?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onCanPlayCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onCanPlayThrough?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onCanPlayThroughCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onDurationChange?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onDurationChangeCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onEmptied?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onEmptiedCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onEncrypted?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onEncryptedCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onEnded?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onEndedCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onLoadedData?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onLoadedDataCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onLoadedMetadata?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onLoadedMetadataCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onLoadStart?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onLoadStartCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onPause?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onPauseCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onPlay?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onPlayCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onPlaying?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onPlayingCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onProgress?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onProgressCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onRateChange?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onRateChangeCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onSeeked?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onSeekedCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onSeeking?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onSeekingCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onStalled?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onStalledCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onSuspend?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onSuspendCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onTimeUpdate?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onTimeUpdateCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onVolumeChange?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onVolumeChangeCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onWaiting?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onWaitingCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onAuxClick?: import("react").MouseEventHandler<HTMLElement> | undefined;
+        onAuxClickCapture?: import("react").MouseEventHandler<HTMLElement> | undefined;
+        onClickCapture?: import("react").MouseEventHandler<HTMLElement> | undefined;
+        onContextMenu?: import("react").MouseEventHandler<HTMLElement> | undefined;
+        onContextMenuCapture?: import("react").MouseEventHandler<HTMLElement> | undefined;
+        onDoubleClick?: import("react").MouseEventHandler<HTMLElement> | undefined;
+        onDoubleClickCapture?: import("react").MouseEventHandler<HTMLElement> | undefined;
+        onDrag?: import("react").DragEventHandler<HTMLElement> | undefined;
+        onDragCapture?: import("react").DragEventHandler<HTMLElement> | undefined;
+        onDragEnd?: import("react").DragEventHandler<HTMLElement> | undefined;
+        onDragEndCapture?: import("react").DragEventHandler<HTMLElement> | undefined;
+        onDragEnter?: import("react").DragEventHandler<HTMLElement> | undefined;
+        onDragEnterCapture?: import("react").DragEventHandler<HTMLElement> | undefined;
+        onDragExit?: import("react").DragEventHandler<HTMLElement> | undefined;
+        onDragExitCapture?: import("react").DragEventHandler<HTMLElement> | undefined;
+        onDragLeave?: import("react").DragEventHandler<HTMLElement> | undefined;
+        onDragLeaveCapture?: import("react").DragEventHandler<HTMLElement> | undefined;
+        onDragOver?: import("react").DragEventHandler<HTMLElement> | undefined;
+        onDragOverCapture?: import("react").DragEventHandler<HTMLElement> | undefined;
+        onDragStart?: import("react").DragEventHandler<HTMLElement> | undefined;
+        onDragStartCapture?: import("react").DragEventHandler<HTMLElement> | undefined;
+        onDrop?: import("react").DragEventHandler<HTMLElement> | undefined;
+        onDropCapture?: import("react").DragEventHandler<HTMLElement> | undefined;
+        onMouseDown?: import("react").MouseEventHandler<HTMLElement> | undefined;
+        onMouseDownCapture?: import("react").MouseEventHandler<HTMLElement> | undefined;
+        onMouseMove?: import("react").MouseEventHandler<HTMLElement> | undefined;
+        onMouseMoveCapture?: import("react").MouseEventHandler<HTMLElement> | undefined;
+        onMouseOut?: import("react").MouseEventHandler<HTMLElement> | undefined;
+        onMouseOutCapture?: import("react").MouseEventHandler<HTMLElement> | undefined;
+        onMouseOver?: import("react").MouseEventHandler<HTMLElement> | undefined;
+        onMouseOverCapture?: import("react").MouseEventHandler<HTMLElement> | undefined;
+        onMouseUp?: import("react").MouseEventHandler<HTMLElement> | undefined;
+        onMouseUpCapture?: import("react").MouseEventHandler<HTMLElement> | undefined;
+        onSelect?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onSelectCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onTouchCancel?: import("react").TouchEventHandler<HTMLElement> | undefined;
+        onTouchCancelCapture?: import("react").TouchEventHandler<HTMLElement> | undefined;
+        onTouchEnd?: import("react").TouchEventHandler<HTMLElement> | undefined;
+        onTouchEndCapture?: import("react").TouchEventHandler<HTMLElement> | undefined;
+        onTouchMove?: import("react").TouchEventHandler<HTMLElement> | undefined;
+        onTouchMoveCapture?: import("react").TouchEventHandler<HTMLElement> | undefined;
+        onTouchStart?: import("react").TouchEventHandler<HTMLElement> | undefined;
+        onTouchStartCapture?: import("react").TouchEventHandler<HTMLElement> | undefined;
+        onPointerDown?: import("react").PointerEventHandler<HTMLElement> | undefined;
+        onPointerDownCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+        onPointerMove?: import("react").PointerEventHandler<HTMLElement> | undefined;
+        onPointerMoveCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+        onPointerUp?: import("react").PointerEventHandler<HTMLElement> | undefined;
+        onPointerUpCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+        onPointerCancel?: import("react").PointerEventHandler<HTMLElement> | undefined;
+        onPointerCancelCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+        onPointerEnter?: import("react").PointerEventHandler<HTMLElement> | undefined;
+        onPointerEnterCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+        onPointerLeave?: import("react").PointerEventHandler<HTMLElement> | undefined;
+        onPointerLeaveCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+        onPointerOver?: import("react").PointerEventHandler<HTMLElement> | undefined;
+        onPointerOverCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+        onPointerOut?: import("react").PointerEventHandler<HTMLElement> | undefined;
+        onPointerOutCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+        onGotPointerCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+        onGotPointerCaptureCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+        onLostPointerCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+        onLostPointerCaptureCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+        onScroll?: import("react").UIEventHandler<HTMLElement> | undefined;
+        onScrollCapture?: import("react").UIEventHandler<HTMLElement> | undefined;
+        onWheel?: import("react").WheelEventHandler<HTMLElement> | undefined;
+        onWheelCapture?: import("react").WheelEventHandler<HTMLElement> | undefined;
+        onAnimationStart?: import("react").AnimationEventHandler<HTMLElement> | undefined;
+        onAnimationStartCapture?: import("react").AnimationEventHandler<HTMLElement> | undefined;
+        onAnimationEnd?: import("react").AnimationEventHandler<HTMLElement> | undefined;
+        onAnimationEndCapture?: import("react").AnimationEventHandler<HTMLElement> | undefined;
+        onAnimationIteration?: import("react").AnimationEventHandler<HTMLElement> | undefined;
+        onAnimationIterationCapture?: import("react").AnimationEventHandler<HTMLElement> | undefined;
+        onTransitionEnd?: import("react").TransitionEventHandler<HTMLElement> | undefined;
+        onTransitionEndCapture?: import("react").TransitionEventHandler<HTMLElement> | undefined;
+        refs?: import("../../api").Refs | undefined;
+        ref: import("../../api").Refs | undefined;
+    };
+};
+interface AbstractBoxProps extends BaseBoxProps {
+    boxType: 'checkbox' | 'radio';
+    css?: SerializedStyles;
+}
+export declare function AbstractBox({ children, text, className, style, search, boxType, css: externalCss, ...props }: AbstractBoxProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export {};

package/lib/radio/component/abstract-box.js

@@ -0,0 +1,98 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AbstractBox = AbstractBox;
+exports.useAbstractBox = useAbstractBox;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _objectSpread3 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _api = require("../../api");
+var _highlightText = require("../../highlight-text");
+var _text = require("../../text");
+var _tooltip = require("../../tooltip");
+var _antd = require("antd");
+var _react = require("react");
+var _style = _interopRequireDefault(require("../style"));
+var _utils = require("./utils");
+var _jsxRuntime = require("@emotion/react/jsx-runtime");
+var _excluded = ["children", "search"],
+  _excluded2 = ["refs", "boxTooltip", "value", "onChange", "inGroup"],
+  _excluded3 = ["children", "text", "className", "style", "search", "boxType", "css"];
+function BoxLabel(_ref) {
+  var children = _ref.children,
+    search = _ref.search,
+    props = (0, _objectWithoutProperties2.default)(_ref, _excluded);
+  if (!children) {
+    return null;
+  }
+  var className = (0, _api.getClassName)('box-label');
+  if ( /*#__PURE__*/(0, _react.isValidElement)(children)) {
+    return (0, _jsxRuntime.jsx)("div", {
+      className: className,
+      children: children
+    });
+  }
+  return (0, _jsxRuntime.jsx)("div", {
+    className: className,
+    children: (0, _jsxRuntime.jsx)(_highlightText.HighlightText, (0, _objectSpread3.default)((0, _objectSpread3.default)({}, props), {}, {
+      text: "".concat(children),
+      highlight: search
+    }))
+  });
+}
+function useAbstractBox(_ref2) {
+  var refs = _ref2.refs,
+    boxTooltip = _ref2.boxTooltip,
+    value = _ref2.value,
+    _onChange = _ref2.onChange,
+    inGroup = _ref2.inGroup,
+    props = (0, _objectWithoutProperties2.default)(_ref2, _excluded2);
+  var _parseHighlightTextAn = (0, _utils.parseHighlightTextAndRestProps)(props),
+    highlightTextProps = _parseHighlightTextAn.highlightTextProps,
+    restProps = _parseHighlightTextAn.restProps;
+  var tooltipProps = (0, _objectSpread3.default)({
+    align: {
+      offset: [0, 1]
+    }
+  }, (0, _text.generateTooltip)(boxTooltip));
+  var boxProps = (0, _objectSpread3.default)((0, _objectSpread3.default)({
+    ref: refs
+  }, restProps), {}, (0, _defineProperty2.default)((0, _defineProperty2.default)({}, inGroup ? 'value' : 'checked', value), "onChange", function onChange(e) {
+    _onChange === null || _onChange === void 0 || _onChange(inGroup ? e : e.target.checked);
+  }));
+  return {
+    highlightTextProps: highlightTextProps,
+    tooltipProps: tooltipProps,
+    boxProps: boxProps
+  };
+}
+function AbstractBox(_ref3) {
+  var children = _ref3.children,
+    text = _ref3.text,
+    className = _ref3.className,
+    style = _ref3.style,
+    search = _ref3.search,
+    boxType = _ref3.boxType,
+    externalCss = _ref3.css,
+    props = (0, _objectWithoutProperties2.default)(_ref3, _excluded3);
+  var _useAbstractBox = useAbstractBox(props),
+    highlightTextProps = _useAbstractBox.highlightTextProps,
+    tooltipProps = _useAbstractBox.tooltipProps,
+    boxProps = _useAbstractBox.boxProps;
+  var BoxComponent = boxType === 'checkbox' ? _antd.Checkbox : _antd.Radio;
+  return (0, _jsxRuntime.jsxs)("label", {
+    css: [_style.default.box(boxType), externalCss],
+    className: (0, _api.combineClassName)(boxType, className),
+    style: style,
+    children: [(0, _jsxRuntime.jsx)(_tooltip.Tooltip, (0, _objectSpread3.default)((0, _objectSpread3.default)({}, tooltipProps), {}, {
+      children: (0, _jsxRuntime.jsx)(BoxComponent, (0, _objectSpread3.default)({}, boxProps))
+    })), (0, _jsxRuntime.jsx)(BoxLabel, (0, _objectSpread3.default)((0, _objectSpread3.default)({
+      search: search
+    }, highlightTextProps), {}, {
+      children: children !== null && children !== void 0 ? children : text
+    }))]
+  });
+}

package/lib/radio/component/index.d.ts

@@ -0,0 +1,2 @@
+import { RadioProps } from "..";
+export declare function Radio(props: RadioProps): import("@emotion/react/jsx-runtime").JSX.Element;

package/lib/radio/component/index.js

@@ -0,0 +1,17 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Radio = Radio;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _radio = require("./radio");
+var _redioGroup = require("./redio-group");
+var _jsxRuntime = require("@emotion/react/jsx-runtime");
+function Radio(props) {
+  if (props.options) {
+    return (0, _jsxRuntime.jsx)(_redioGroup.RadioGroup, (0, _objectSpread2.default)({}, props));
+  }
+  return (0, _jsxRuntime.jsx)(_radio.InternalRadio, (0, _objectSpread2.default)({}, props));
+}

package/lib/radio/component/radio.d.ts

@@ -0,0 +1,2 @@
+import { BaseBoxProps } from "..";
+export declare function InternalRadio(props: BaseBoxProps): import("@emotion/react/jsx-runtime").JSX.Element;

package/lib/radio/component/radio.js

@@ -0,0 +1,17 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InternalRadio = InternalRadio;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _style = _interopRequireDefault(require("../style"));
+var _abstractBox = require("./abstract-box");
+var _jsxRuntime = require("@emotion/react/jsx-runtime");
+function InternalRadio(props) {
+  return (0, _jsxRuntime.jsx)(_abstractBox.AbstractBox, (0, _objectSpread2.default)((0, _objectSpread2.default)({}, props), {}, {
+    boxType: "radio",
+    css: _style.default.radio
+  }));
+}

package/lib/radio/component/redio-group.d.ts

@@ -0,0 +1,2 @@
+import { RadioProps } from '../type';
+export declare function RadioGroup({ refs, vertical, gap, wrap, ...restProps }: RadioProps): import("@emotion/react/jsx-runtime").JSX.Element;

package/lib/radio/component/redio-group.js

@@ -0,0 +1,57 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RadioGroup = RadioGroup;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _api = require("../../api");
+var _css = require("@emotion/css");
+var _antd = require("antd");
+var _lodash = _interopRequireDefault(require("lodash"));
+var _style = _interopRequireDefault(require("../style"));
+var _radio = require("./radio");
+var _useRadio2 = require("./use-radio");
+var _jsxRuntime = require("@emotion/react/jsx-runtime");
+var _react = require("@emotion/react");
+var _excluded = ["refs", "vertical", "gap", "wrap"],
+  _excluded2 = ["options"],
+  _excluded3 = ["label", "originLabel"];
+var Group = _antd.Radio.Group;
+function RadioGroup(_ref) {
+  var refs = _ref.refs,
+    vertical = _ref.vertical,
+    gap = _ref.gap,
+    wrap = _ref.wrap,
+    restProps = (0, _objectWithoutProperties2.default)(_ref, _excluded);
+  var _useRadio = (0, _useRadio2.useRadio)(restProps),
+    options = _useRadio.options,
+    props = (0, _objectWithoutProperties2.default)(_useRadio, _excluded2);
+  if (props.optionType === 'button') {
+    return (0, _jsxRuntime.jsx)(Group, (0, _objectSpread2.default)((0, _objectSpread2.default)({}, props), {}, {
+      options: options
+    }));
+  }
+  var classString = (0, _css.cx)((0, _defineProperty2.default)({}, (0, _api.getClassName)('radio-vertical'), vertical), props.className);
+  return (0, _jsxRuntime.jsx)(Group, (0, _objectSpread2.default)((0, _objectSpread2.default)({
+    css: _style.default.wrapper({
+      vertical: vertical,
+      gap: gap,
+      wrap: wrap
+    }),
+    className: classString
+  }, props), {}, {
+    children: _lodash.default.map(options, function (_ref2, index) {
+      var label = _ref2.label,
+        originLabel = _ref2.originLabel,
+        option = (0, _objectWithoutProperties2.default)(_ref2, _excluded3);
+      return (0, _react.createElement)(_radio.InternalRadio, (0, _objectSpread2.default)((0, _objectSpread2.default)({}, option), {}, {
+        inGroup: true,
+        key: index
+      }), label);
+    })
+  }));
+}

package/lib/radio/component/use-box-options.d.ts

@@ -0,0 +1,6 @@
+import { BaseSelectProps } from "../../select";
+export declare function useBoxOptions<T = any>({ search, ...props }: BaseSelectProps): T & {
+    value: any;
+    options: import("../../select").SelectOptions | undefined;
+    displayOptions: any[];
+};