@nutui/nutui-react-taro 2.0.0-alpha.8 → 2.0.0-beta.1

package/dist/esm/popover.taro-ae72d2de.js

@@ -0,0 +1,201 @@
+import React, { useRef, useState, useEffect } from "react";
+import classNames from "classnames";
+import { P as Popup } from "./popup.taro-23f882b0.js";
+import Taro from "@tarojs/taro";
+import { a as getRect, g as getRectByTaro } from "./use-client-rect-2bb6c562.js";
+import { C as ComponentDefaults } from "./typings-11d83a22.js";
+const defaultProps = {
+  ...ComponentDefaults,
+  list: [],
+  location: "bottom",
+  visible: false,
+  offset: [0, 12],
+  targetId: "",
+  className: "",
+  showArrow: true,
+  overlay: false,
+  closeOnClickOutside: true,
+  closeOnClickAction: true,
+  onClick: () => {
+  },
+  onOpen: () => {
+  },
+  onClose: () => {
+  }
+};
+const classPrefix = `nut-popover`;
+const Popover = (props) => {
+  const { children, list, location, visible, offset, targetId, overlay, closeOnClickOutside, closeOnClickAction, className, showArrow, style, onClick, onOpen, onClose, onSelect, ...rest } = {
+    ...defaultProps,
+    ...props
+  };
+  const popoverRef = useRef(null);
+  const popoverContentRef = useRef(null);
+  const [showPopup, setShowPopup] = useState(false);
+  const [elWidth, setElWidth] = useState(0);
+  const [elHeight, setElHeight] = useState(0);
+  const [rootPosition, setRootPosition] = useState();
+  useEffect(() => {
+    setShowPopup(visible);
+    if (visible) {
+      setTimeout(() => {
+        getContentWidth();
+      }, 0);
+    }
+  }, [visible]);
+  const getContentWidth = async () => {
+    let rect;
+    if (targetId) {
+      if (Taro.getEnv() === Taro.ENV_TYPE.WEB) {
+        rect = getRect(document.querySelector(`#${targetId}`));
+      } else {
+        rect = await getRectTaro(targetId);
+      }
+    } else {
+      rect = await getRectByTaro(popoverRef.current);
+    }
+    setRootPosition({
+      width: rect.width,
+      height: rect.height,
+      left: rect.left,
+      top: rect.top,
+      right: rect.right
+    });
+    setTimeout(() => {
+      getPopoverContentW();
+    }, 300);
+  };
+  const getRectTaro = async (targetId2) => {
+    return new Promise((resolve) => {
+      const query = Taro.createSelectorQuery();
+      query.select(`#${targetId2}`) && query.select(`#${targetId2}`).boundingClientRect();
+      query.exec((res) => {
+        resolve(res[0]);
+      });
+    });
+  };
+  const getPopoverContentW = async () => {
+    const rectContent = await getRectByTaro(popoverContentRef.current);
+    setElWidth(rectContent.width);
+    setElHeight(rectContent.height);
+  };
+  const clickAway = () => {
+    if (closeOnClickOutside) {
+      props.onClick && props.onClick();
+      onClose && onClose();
+    }
+  };
+  const classes = classNames({
+    [`${classPrefix}`]: true
+  }, className);
+  const popoverArrow = () => {
+    const prefixCls = "nut-popover-arrow";
+    const loca = location;
+    const direction = loca.split("-")[0];
+    return `${prefixCls} ${prefixCls}-${direction} ${prefixCls}--${loca}`;
+  };
+  const getRootPosition = () => {
+    const styles = {};
+    if (!rootPosition) {
+      styles.visibility = "hidden";
+      return styles;
+    }
+    const contentWidth = elWidth;
+    const contentHeight = elHeight;
+    const { width, height, left, top, right } = rootPosition;
+    const direction = location.split("-")[0];
+    const skew = location.split("-")[1];
+    let cross = 0;
+    let parallel = 0;
+    if (Array.isArray(offset) && offset.length === 2) {
+      cross += +offset[1];
+      parallel += +offset[0];
+    }
+    if (width) {
+      if (["bottom", "top"].includes(direction)) {
+        const h = direction === "bottom" ? height + cross : -(contentHeight + cross);
+        styles.top = `${top + h}px`;
+        if (!skew) {
+          styles.left = `${-(contentWidth - width) / 2 + left + parallel}px`;
+        }
+        if (skew === "start") {
+          styles.left = `${left + parallel}px`;
+        }
+        if (skew === "end") {
+          styles.left = `${right + parallel}px`;
+        }
+      }
+      if (["left", "right"].includes(direction)) {
+        const contentW = direction === "left" ? -(contentWidth + cross) : width + cross;
+        styles.left = `${left + contentW}px`;
+        if (!skew) {
+          styles.top = `${top - contentHeight / 2 + height / 2 - 4 + parallel}px`;
+        }
+        if (skew === "start") {
+          styles.top = `${top + parallel}px`;
+        }
+        if (skew === "end") {
+          styles.top = `${top + height + parallel}px`;
+        }
+      }
+    }
+    if (elWidth === 0) {
+      styles.visibility = "hidden";
+    } else {
+      styles.visibility = "initial";
+    }
+    return styles;
+  };
+  const handleSelect = (item, index) => {
+    if (!item.disabled) {
+      onSelect && onSelect(item, index);
+    }
+    if (closeOnClickAction) {
+      props.onClick && props.onClick();
+      onClose && onClose();
+    }
+  };
+  return React.createElement(
+    React.Fragment,
+    null,
+    !targetId && React.createElement("div", { className: "nut-popover-wrapper", ref: popoverRef, onClick: () => {
+      props.onClick && props.onClick();
+      if (!visible) {
+        onOpen && onOpen();
+      } else {
+        onClose && onClose();
+      }
+    }, style }, Array.isArray(children) ? children[0] : children),
+    React.createElement(
+      "div",
+      { className: classes, style: getRootPosition() },
+      React.createElement(
+        Popup,
+        { className: `nut-popover-content nut-popover-content--${location}`, position: "default", overlay, visible: showPopup, ...rest },
+        React.createElement(
+          "div",
+          { className: "nut-popover-content-group", ref: popoverContentRef },
+          showArrow && React.createElement("div", { className: popoverArrow() }),
+          Array.isArray(children) ? children[1] : "",
+          list.map((item, index) => {
+            return React.createElement(
+              "div",
+              { className: classNames({
+                "nut-popover-menu-item": true,
+                "nut-popover-menu-disabled": item.disabled
+              }, item.className), key: item.key, onClick: () => handleSelect(item, index) },
+              item.icon ? item.icon : null,
+              React.createElement("div", { className: "nut-popover-menu-item-name" }, item.name)
+            );
+          })
+        )
+      ),
+      showPopup && React.createElement("div", { className: "nut-popover-content-bg", onClick: clickAway, onTouchMove: clickAway })
+    )
+  );
+};
+Popover.defaultProps = defaultProps;
+Popover.displayName = "NutPopover";
+export {
+  Popover as P
+};

package/dist/esm/{popup.taro-e756f3fc.js → popup.taro-23f882b0.js}

@@ -29,7 +29,7 @@ const defaultProps = {
 };
 let _zIndex = 2e3;
 const Popup = (props) => {
-  const { children, visible, overlay, closeOnOverlayClick, overlayStyle, overlayClassName, zIndex, lockScroll, duration, closeable, closeIconPosition, closeIcon, style, transition, round, position, className, destroyOnClose, portal, onOpen, onClose, onClickOverlay, onClickCloseIcon, afterShow, afterClose, onClick } = props;
+  const { children, visible, overlay, closeOnOverlayClick, overlayStyle, overlayClassName, zIndex, lockScroll, duration, closeable, closeIconPosition, closeIcon, left, title, style, transition, round, position, className, destroyOnClose, portal, onOpen, onClose, onClickOverlay, onClickCloseIcon, afterShow, afterClose, onClick } = props;
   const [index, setIndex] = useState(zIndex || _zIndex);
   const [innerVisible, setInnerVisible] = useState(visible);
   const [showChildren, setShowChildren] = useState(true);
@@ -79,6 +79,7 @@ const Popup = (props) => {
     }
   };
   const onHandleClickOverlay = (e) => {
+    e.stopPropagation();
     if (closeOnOverlayClick) {
       const closed = onClickOverlay && onClickOverlay(e);
       closed && close();
@@ -114,6 +115,14 @@ const Popup = (props) => {
     }
     return null;
   };
+  const renderTitle = () => {
+    return React.createElement(React.Fragment, null, position === "bottom" && React.createElement(
+      React.Fragment,
+      null,
+      left && React.createElement(View, { className: `${classPrefix}-left-icon` }, left),
+      title && React.createElement(View, { className: `${classPrefix}-title` }, title)
+    ));
+  };
   const renderPop = () => {
     return React.createElement(
       CSSTransition,
@@ -121,8 +130,9 @@ const Popup = (props) => {
       React.createElement(
         View,
         { style: popStyles, className: popClassName, onClick: onHandleClick },
-        showChildren ? children : "",
-        renderIcon()
+        renderTitle(),
+        renderIcon(),
+        showChildren ? children : ""
       )
     );
   };

package/dist/esm/{price.taro-c4f45310.js → price.taro-479f1b82.js}

@@ -1,21 +1,21 @@
 import React from "react";
-import { c as cn } from "./bem-cdccae08.js";
+import { C as ComponentDefaults } from "./typings-11d83a22.js";
 const defaultProps = {
+  ...ComponentDefaults,
   price: 0,
-  needSymbol: true,
   symbol: "¥",
-  decimalDigits: 2,
+  digits: 2,
   thousands: false,
   position: "before",
   size: "large",
-  className: ""
+  line: false
 };
 const Price = (props) => {
-  const { price, needSymbol, symbol, decimalDigits, thousands, position, size, className, ...rest } = {
+  const { price, symbol, digits, thousands, position, size, line, className, style, ...rest } = {
     ...defaultProps,
     ...props
   };
-  const b = cn("price");
+  const classPrefix = "nut-price";
   const replaceSpecialChar = (url) => {
     url = url.replace(/"/g, '"');
     url = url.replace(/&/g, "&");
@@ -26,7 +26,7 @@ const Price = (props) => {
     return url;
   };
   const showSymbol = () => {
-    return { __html: needSymbol ? replaceSpecialChar(symbol) : "" };
+    return { __html: symbol ? replaceSpecialChar(symbol) : "" };
   };
   const checkPoint = (price2) => {
     return String(price2).indexOf(".") > 0;
@@ -36,7 +36,7 @@ const Price = (props) => {
       num = 0;
     }
     if (checkPoint(num)) {
-      num = Number(num).toFixed(decimalDigits);
+      num = Number(num).toFixed(digits);
       num = typeof num.split(".") === "string" ? num.split(".") : num.split(".")[0];
     } else {
       num = num.toString();
@@ -51,26 +51,26 @@ const Price = (props) => {
       decimalNum = 0;
     }
     if (checkPoint(decimalNum)) {
-      decimalNum = Number(decimalNum).toFixed(decimalDigits);
+      decimalNum = Number(decimalNum).toFixed(digits);
       decimalNum = typeof decimalNum.split(".") === "string" ? 0 : decimalNum.split(".")[1] || 0;
     } else {
       decimalNum = 0;
     }
     const result = `0.${decimalNum}`;
-    const resultFixed = Number(result).toFixed(decimalDigits);
+    const resultFixed = Number(result).toFixed(digits);
     return String(resultFixed).substring(2, resultFixed.length);
   };
   const renderSymbol = () => {
-    return React.createElement("div", { className: `${b("symbol")} ${b(`symbol-${size}`)}`, dangerouslySetInnerHTML: showSymbol() });
+    return React.createElement("div", { className: `${classPrefix}__symbol ${classPrefix}__symbol-${size}`, dangerouslySetInnerHTML: showSymbol() });
   };
   return React.createElement(
     "div",
-    { className: `${b()} ${className}`, ...rest },
-    needSymbol && position === "before" ? renderSymbol() : null,
-    React.createElement("div", { className: `${b("integer")} ${b(`integer-${size}`)}` }, formatThousands(price)),
-    decimalDigits !== 0 ? React.createElement("div", { className: `${b("decimal")} ${b(`decimal-${size}`)}` }, ".") : null,
-    React.createElement("div", { className: `${b("decimal")} ${b(`decimal-${size}`)}` }, formatDecimal(price)),
-    needSymbol && position === "after" ? renderSymbol() : null
+    { className: `${classPrefix} ${className} ${line ? `${classPrefix}--line` : ""}`, style, ...rest },
+    symbol && position === "before" ? renderSymbol() : null,
+    React.createElement("div", { className: `${classPrefix}__integer ${classPrefix}__integer-${size}` }, formatThousands(price)),
+    digits !== 0 ? React.createElement("div", { className: `${classPrefix}__decimal ${classPrefix}__decimal-${size}` }, ".") : null,
+    React.createElement("div", { className: `${classPrefix}__decimal ${classPrefix}__decimal-${size}` }, formatDecimal(price)),
+    symbol && position === "after" ? renderSymbol() : null
   );
 };
 Price.defaultProps = defaultProps;

package/dist/esm/{progress.taro-ff63be75.js → progress.taro-437b9f6a.js}

@@ -1,14 +1,15 @@
-import React from "react";
+import React, { useState, useEffect } from "react";
 import classNames from "classnames";
 import { C as ComponentDefaults } from "./typings-11d83a22.js";
 const defaultProps = {
   ...ComponentDefaults,
   percent: 0,
   showText: false,
-  animated: false
+  animated: false,
+  delay: 0
 };
 const Progress = (props) => {
-  const { className, style, percent, background, color, strokeWidth, showText, animated, children, ...rest } = {
+  const { className, style, percent, background, color, strokeWidth, showText, animated, children, delay, ...rest } = {
     ...defaultProps,
     ...props
   };
@@ -21,17 +22,33 @@ const Progress = (props) => {
     height: `${strokeWidth}px`,
     background
   };
+  const [displayPercent, setDispalyPercent] = useState(0);
   const stylesInner = {
-    width: `${percent}%`,
+    width: `${displayPercent}%`,
     background: color
   };
+  useEffect(() => {
+    setDispalyPercent(percent);
+  }, [percent]);
+  useEffect(() => {
+    let timer = null;
+    if (delay) {
+      setDispalyPercent(0);
+      timer = setTimeout(() => {
+        setDispalyPercent(percent);
+      }, delay);
+    }
+    return () => {
+      timer && clearTimeout(timer);
+    };
+  }, []);
   return React.createElement(
     "div",
     { className: classNames(classPrefix, className), style, ...rest },
     React.createElement(
       "div",
       { className: `${classPrefix}-outer`, style: stylesOuter },
-      React.createElement("div", { className: classesInner, style: stylesInner }, showText && React.createElement("div", { className: `${classPrefix}-text`, style: { left: `${percent}%` } }, children || React.createElement(
+      React.createElement("div", { className: classesInner, style: stylesInner }, showText && React.createElement("div", { className: `${classPrefix}-text`, style: { left: `${displayPercent}%` } }, children || React.createElement(
         "div",
         { className: `${classPrefix}-text__inner`, style: {
           background: color

package/dist/esm/pulltorefresh.taro-71ad5d15.js

@@ -0,0 +1,138 @@
+import React, { useRef, useState } from "react";
+import { View } from "@tarojs/components";
+import { u as useConfig } from "./configprovider.taro-a7f3bcfd.js";
+import { u as useTouch } from "./use-touch-ff43512c.js";
+import { C as ComponentDefaults } from "./typings-11d83a22.js";
+function bound(position, min, max) {
+  let ret = position;
+  if (min !== void 0) {
+    ret = Math.max(position, min);
+  }
+  if (max !== void 0) {
+    ret = Math.min(ret, max);
+  }
+  return ret;
+}
+function rubberband(distance, dimension, constant) {
+  return distance * dimension * constant / (dimension + constant * distance);
+}
+function rubberbandIfOutOfBounds(position, min, max, dimension, constant = 0.15) {
+  if (constant === 0)
+    return bound(position, min, max);
+  if (position < min)
+    return -rubberband(min - position, dimension, constant) + min;
+  if (position > max)
+    return +rubberband(position - max, dimension, constant) + max;
+  return position;
+}
+const sleep = (time) => new Promise((resolve) => setTimeout(resolve, time));
+const defaultProps = {
+  ...ComponentDefaults,
+  pullingText: "",
+  canReleaseText: "",
+  refreshingText: "",
+  completeText: "",
+  completeDelay: 500,
+  disabled: false,
+  headHeight: 40,
+  threshold: 60,
+  scrollTop: 0,
+  onRefresh: () => {
+  }
+};
+const PullToRefresh = (p) => {
+  const classPrefix = "nut-pulltorefresh";
+  const { locale } = useConfig();
+  const touch = useTouch();
+  const props = {
+    ...defaultProps,
+    ...p,
+    ...{
+      pullingText: p.pullingText || locale.pullToRefresh.pullingText,
+      canReleaseText: p.canReleaseText || locale.pullToRefresh.canReleaseText,
+      refreshingText: p.refreshingText || locale.pullToRefresh.refreshingText,
+      completeText: p.completeText || locale.pullToRefresh.completeText
+    }
+  };
+  const headHeight = props.headHeight;
+  const threshold = props.threshold;
+  const pullingRef = useRef(false);
+  const [status, setStatus] = useState("pulling");
+  const [height, setHeight] = useState(0);
+  const renderStatusText = () => {
+    var _a;
+    if (props.renderText) {
+      return (_a = props.renderText) == null ? void 0 : _a.call(props, status);
+    }
+    if (status === "pulling")
+      return props.pullingText;
+    if (status === "canRelease")
+      return props.canReleaseText;
+    if (status === "refreshing")
+      return props.refreshingText;
+    if (status === "complete")
+      return props.completeText;
+    return "";
+  };
+  const handleTouchStart = (e) => {
+    touch.start(e);
+  };
+  const handleTouchMove = (e) => {
+    if (props.scrollTop > 0) {
+      return;
+    }
+    if (status === "refreshing" || status === "complete")
+      return;
+    touch.move(e);
+    if (touch.isVertical()) {
+      pullingRef.current = true;
+      setHeight(Math.max(rubberbandIfOutOfBounds(touch.deltaY, 0, 0, headHeight * 5, 0.5), 0));
+      setStatus(height > threshold ? "canRelease" : "pulling");
+    }
+  };
+  async function doRefresh() {
+    setHeight(headHeight);
+    setStatus("refreshing");
+    try {
+      await props.onRefresh();
+      setStatus("complete");
+    } catch (e) {
+      setHeight(0);
+      setStatus("pulling");
+      throw e;
+    }
+    if (props.completeDelay > 0) {
+      await sleep(props.completeDelay);
+    }
+    setHeight(0);
+    setStatus("pulling");
+  }
+  const handleTouchEnd = () => {
+    pullingRef.current = false;
+    if (status === "canRelease") {
+      doRefresh();
+    } else {
+      setHeight(0);
+      setStatus("pulling");
+    }
+  };
+  const springStyles = {
+    height: `${height}px`,
+    ...!pullingRef.current ? { transition: "height .3s ease" } : {}
+  };
+  return React.createElement(
+    View,
+    { className: `${classPrefix} ${props.className}`, style: props.style, onTouchStart: handleTouchStart, onTouchMove: handleTouchMove, onTouchEnd: handleTouchEnd },
+    React.createElement(
+      View,
+      { style: springStyles, className: `${classPrefix}-head` },
+      React.createElement("div", { className: `${classPrefix}-head-content`, style: { height: headHeight } }, renderStatusText())
+    ),
+    React.createElement("div", { className: `${classPrefix}-content` }, props.children)
+  );
+};
+PullToRefresh.defaultProps = defaultProps;
+PullToRefresh.displayName = "NutPullToRefresh";
+export {
+  PullToRefresh as P
+};

package/dist/esm/radio.taro-5d6ca4ad.js

@@ -0,0 +1,153 @@
+import React, { useCallback, useContext } from "react";
+import { CheckChecked, CheckNormal } from "@nutui/icons-react-taro";
+import classNames from "classnames";
+import { C as ComponentDefaults } from "./typings-11d83a22.js";
+import { u as usePropsValue } from "./use-props-value-7ac1b1b5.js";
+const RadioContext = React.createContext(null);
+const defaultProps$1 = {
+  labelPosition: "right",
+  onChange: (value) => {
+  },
+  direction: "vertical",
+  options: []
+};
+const classPrefix = "nut-radiogroup";
+const RadioGroup = React.forwardRef((props, ref) => {
+  const { children, className, value, defaultValue, onChange, labelPosition, direction, options, disabled, ...rest } = { ...defaultProps$1, ...props };
+  const [val2State, setVal2State] = usePropsValue({
+    defaultValue: props.defaultValue,
+    value: props.value,
+    finalValue: "",
+    onChange
+  });
+  const renderOptionsChildren = useCallback(() => {
+    return options == null ? void 0 : options.map(({ label, value: value2, disabled: disabled2, onChange: onChange2, ...rest2 }) => {
+      return React.createElement(Radio, { ...rest2, key: value2 == null ? void 0 : value2.toString(), children: label, value: value2, disabled: disabled2, onChange: onChange2, labelPosition, checked: value2 === val2State });
+    });
+  }, [options]);
+  return React.createElement(
+    RadioContext.Provider,
+    { value: {
+      labelPosition: labelPosition || "right",
+      disabled,
+      value: val2State,
+      check: (value2) => {
+        setVal2State(value2);
+      },
+      uncheck: () => {
+        setVal2State("");
+      }
+    } },
+    React.createElement("div", { className: classNames(classPrefix, className, {
+      [`${classPrefix}--${props.direction}`]: props.direction
+    }), ...rest }, (options == null ? void 0 : options.length) ? renderOptionsChildren() : children)
+  );
+});
+RadioGroup.defaultProps = defaultProps$1;
+RadioGroup.displayName = "NutRadioGroup";
+const defaultProps = {
+  ...ComponentDefaults,
+  disabled: false,
+  shape: "round",
+  value: "",
+  labelPosition: "right",
+  icon: null,
+  activeIcon: null,
+  onChange: (checked) => {
+  }
+};
+const Radio = (props) => {
+  const classPrefix2 = "nut-radio";
+  const { children, className, style, checked, defaultChecked, shape, value, icon, activeIcon, onChange, ...others } = {
+    ...defaultProps,
+    ...props
+  };
+  let { labelPosition, disabled, ...rest } = others;
+  let [checkedStatement, setCheckedStatement] = usePropsValue({
+    value: checked,
+    defaultValue: defaultChecked,
+    finalValue: false,
+    onChange
+  });
+  const context = useContext(RadioContext);
+  if (context) {
+    checkedStatement = context.value === value;
+    if (context.labelPosition !== void 0) {
+      labelPosition = context.labelPosition;
+    }
+    if (context.disabled !== void 0) {
+      disabled = context.disabled;
+    }
+    setCheckedStatement = (value2) => {
+      if (value2) {
+        context.check(props.value === void 0 ? "" : props.value);
+      } else {
+        context.uncheck();
+      }
+    };
+  }
+  const renderLabel = () => {
+    return React.createElement("div", { className: classNames(`${classPrefix2}__label`, {
+      [`${classPrefix2}__label--disabled`]: disabled
+    }) }, children);
+  };
+  const renderButton = () => {
+    return React.createElement("div", { className: classNames(`${classPrefix2}__button`, {
+      [`${classPrefix2}__button--active`]: checkedStatement,
+      [`${classPrefix2}__button--disabled`]: disabled
+    }) }, children);
+  };
+  const color = () => {
+    return {
+      [`${classPrefix2}__icon--disable`]: disabled,
+      [`${classPrefix2}__icon`]: checkedStatement,
+      [`${classPrefix2}__icon--unchecked`]: !checkedStatement
+    };
+  };
+  const renderIcon = () => {
+    const { icon: icon2, activeIcon: activeIcon2 } = props;
+    if (checkedStatement) {
+      return React.isValidElement(activeIcon2) ? React.cloneElement(activeIcon2, {
+        ...activeIcon2.props,
+        className: classNames(color())
+      }) : React.createElement(CheckChecked, { className: classNames(color()) });
+    }
+    return React.isValidElement(icon2) ? React.cloneElement(icon2, {
+      ...icon2.props,
+      className: classNames(color())
+    }) : React.createElement(CheckNormal, { className: classNames(color()) });
+  };
+  const reverse = labelPosition === "left";
+  const renderRadioItem = () => {
+    if (shape === "button") {
+      return renderButton();
+    }
+    if (reverse) {
+      return React.createElement(
+        React.Fragment,
+        null,
+        renderLabel(),
+        renderIcon()
+      );
+    }
+    return React.createElement(
+      React.Fragment,
+      null,
+      renderIcon(),
+      renderLabel()
+    );
+  };
+  const handleClick = (e) => {
+    if (disabled || checkedStatement)
+      return;
+    setCheckedStatement(!checkedStatement);
+  };
+  return React.createElement("div", { className: `${classPrefix2} ${className} ${reverse ? `${classPrefix2}--reverse` : ""}`, style, onClick: handleClick, ...rest }, renderRadioItem());
+};
+Radio.defaultProps = defaultProps;
+Radio.displayName = "NutRadio";
+Radio.Group = RadioGroup;
+export {
+  Radio as R,
+  RadioGroup as a
+};

package/dist/esm/{range.taro-615e193a.js → range.taro-a1d1ad25.js}

@@ -2,7 +2,7 @@ import React, { useState, useRef, useEffect, useCallback } from "react";
 import classNames from "classnames";
 import { View } from "@tarojs/components";
 import { u as useTouch } from "./use-touch-ff43512c.js";
-import { g as getRectByTaro } from "./use-client-rect-f317804e.js";
+import { g as getRectByTaro } from "./use-client-rect-2bb6c562.js";
 import { C as ComponentDefaults } from "./typings-11d83a22.js";
 import { u as usePropsValue } from "./use-props-value-7ac1b1b5.js";
 const defaultProps = {