@nutui/nutui-react-taro 2.0.0-alpha.4 → 2.0.0-alpha.6

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

@@ -0,0 +1,162 @@
+import React, { useRef, useState, useEffect } from "react";
+import { O as Overlay } from "./overlay.taro-75012bd3.js";
+import { g as getRectByTaro } from "./use-client-rect-f317804e.js";
+import { C as ComponentDefaults } from "./typings-11d83a22.js";
+function fillRef(ref, node) {
+  if (typeof ref === "function") {
+    ref(node);
+  } else if (typeof ref === "object" && ref && "current" in ref) {
+    ref.current = node;
+  }
+}
+function composeRef(...refs) {
+  return (node) => {
+    refs.forEach((ref) => {
+      fillRef(ref, node);
+    });
+  };
+}
+class Trigger extends React.Component {
+  fireEvents(type, e) {
+    const childCallback = this.props.children.props[type];
+    if (childCallback) {
+      childCallback(e);
+    }
+    const callback = this.props[type];
+    if (callback) {
+      callback(e);
+    }
+  }
+  render() {
+    const { children, className = "" } = this.props;
+    const child = React.Children.only(children);
+    const newChildProps = {
+      key: "trigger"
+    };
+    if (child && child.props && child.props.className) {
+      newChildProps.className = className;
+    }
+    const cloneProps = {
+      ...newChildProps
+    };
+    cloneProps.ref = composeRef(this.props.forwardedRef, child.ref);
+    const trigger = React.cloneElement(child, cloneProps);
+    return trigger;
+  }
+}
+const defaultProps = {
+  ...ComponentDefaults,
+  list: [],
+  theme: "light",
+  location: "bottom",
+  visible: false,
+  offset: 20,
+  className: "",
+  onClick: (e) => {
+  },
+  onChoose: (item, index) => {
+  }
+};
+const Popover = (props) => {
+  const { children, list, theme, location, visible, offset, className, style, onClick, onChoose, ...reset } = {
+    ...defaultProps,
+    ...props
+  };
+  const goodItem = useRef(null);
+  setTimeout(async () => {
+    if (goodItem.current) {
+      const res = await getRectByTaro(goodItem.current);
+      setElWidth(res == null ? void 0 : res.width);
+      setElHeight(res == null ? void 0 : res.height);
+    }
+  });
+  const [classes, setClasses] = useState("");
+  const [elWidth, setElWidth] = useState(0);
+  const [elHeight, setElHeight] = useState(0);
+  const [popoverContent, setPopoverContent] = useState("");
+  const [popoverArrow, setPopoverArrow] = useState("");
+  useEffect(() => {
+    setClasses(classesSelf());
+    setPopoverContent(popoverContentSelf());
+    setPopoverArrow(popoverArrowSelf());
+  }, [list, theme]);
+  const getStyle = () => {
+    const offNumer = Number(offset) ? Number(offset) : 0;
+    const style2 = {};
+    if (location.includes("top")) {
+      style2.bottom = `${elHeight + offNumer}px`;
+    } else if (location.includes("right")) {
+      style2.left = `${elWidth + offNumer}px`;
+    } else if (location.includes("left")) {
+      style2.right = `${elWidth + offNumer}px`;
+    } else {
+      style2.top = `${elHeight + offNumer}px`;
+    }
+    return style2;
+  };
+  const classesSelf = () => {
+    const prefixCls = "nut-popover";
+    return `${prefixCls} ${theme ? `${prefixCls}--${theme}` : ""}`;
+  };
+  const popoverContentSelf = () => {
+    const prefixCls = "popover-content";
+    return `${prefixCls}-show ${prefixCls} ${location ? `${prefixCls}--${location}` : ""}`;
+  };
+  const filter = () => {
+    const ms = ["top", "bottom", "left", "right"];
+    return ms.filter((m) => location.includes(m))[0];
+  };
+  const popoverArrowSelf = () => {
+    const prefixCls = "popover-arrow";
+    return `${prefixCls} ${prefixCls}-${filter()} ${location ? `${prefixCls}--${location}` : ""}`;
+  };
+  const handleClick = (e) => {
+    if (props.onClick) {
+      props.onClick(e);
+    }
+  };
+  const handleChoose = (item, index) => {
+    if (!item.disabled) {
+      onChoose(item, index);
+    }
+  };
+  return React.createElement(
+    React.Fragment,
+    null,
+    React.createElement(
+      "div",
+      { className: `${classes} ${className}`, style: { ...style }, ...reset },
+      React.createElement(
+        Trigger,
+        { forwardedRef: goodItem },
+        React.createElement(
+          "div",
+          { onClick: (e) => handleClick(e) },
+          Array.isArray(children) ? children[0] : children,
+          visible ? React.createElement(
+            "div",
+            { className: `${popoverContent}`, style: getStyle() },
+            React.createElement("div", { className: `${popoverArrow}` }),
+            Array.isArray(children) ? children[1] : "",
+            React.createElement("div", null, list.map((item, i) => {
+              return React.createElement(
+                "div",
+                { key: item.name, className: `popover-menu-item ${item.disabled ? "disabled" : ""}`, onClick: () => {
+                  handleChoose(item, i);
+                } },
+                item.icon ? item.icon : null,
+                React.createElement("div", { className: "popover-menu-item-name" }, item.name)
+              );
+            }))
+          ) : null
+        )
+      )
+    ),
+    visible ? React.createElement(Overlay, { visible, onClick: (e) => handleClick(e), style: { background: "transparent" } }) : null
+  );
+};
+Popover.defaultProps = defaultProps;
+Popover.displayName = "NutPopover";
+export {
+  Popover as P
+};

package/dist/esm/popup.taro-e756f3fc.js

@@ -0,0 +1,150 @@
+import React, { useState, useEffect } from "react";
+import { createPortal } from "react-dom";
+import { CSSTransition } from "react-transition-group";
+import classNames from "classnames";
+import { Close } from "@nutui/icons-react-taro";
+import { View } from "@tarojs/components";
+import { d as defaultOverlayProps, O as Overlay } from "./overlay.taro-75012bd3.js";
+import { C as ComponentDefaults } from "./typings-11d83a22.js";
+const defaultProps = {
+  ...ComponentDefaults,
+  position: "center",
+  transition: "",
+  overlayStyle: {},
+  overlayClassName: "",
+  closeable: false,
+  closeIconPosition: "top-right",
+  closeIcon: "close",
+  destroyOnClose: false,
+  portal: null,
+  overlay: true,
+  round: false,
+  onOpen: () => {
+  },
+  onClose: () => {
+  },
+  onClickOverlay: (e) => true,
+  onClickCloseIcon: (e) => true,
+  ...defaultOverlayProps
+};
+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 [index, setIndex] = useState(zIndex || _zIndex);
+  const [innerVisible, setInnerVisible] = useState(visible);
+  const [showChildren, setShowChildren] = useState(true);
+  const [transitionName, setTransitionName] = useState("");
+  const classPrefix = "nut-popup";
+  const baseStyle = {
+    zIndex: index,
+    animationDuration: `${duration}s`
+  };
+  const overlayStyles = {
+    ...overlayStyle,
+    ...baseStyle
+  };
+  const popStyles = {
+    ...style,
+    ...baseStyle
+  };
+  const popClassName = classNames({
+    round,
+    [`${classPrefix}`]: true,
+    [`${classPrefix}-${position}`]: true,
+    [`${className || ""}`]: true
+  });
+  const closeClasses = classNames({
+    [`${classPrefix}__close-icon`]: true,
+    [`${classPrefix}__close-icon--${closeIconPosition}`]: true
+  });
+  const open = () => {
+    if (!innerVisible) {
+      setInnerVisible(true);
+      setIndex(++_zIndex);
+    }
+    if (destroyOnClose) {
+      setShowChildren(true);
+    }
+    onOpen && onOpen();
+  };
+  const close = () => {
+    if (innerVisible) {
+      setInnerVisible(false);
+      if (destroyOnClose) {
+        setTimeout(() => {
+          setShowChildren(false);
+        }, Number(duration) * 1e3);
+      }
+      onClose && onClose();
+    }
+  };
+  const onHandleClickOverlay = (e) => {
+    if (closeOnOverlayClick) {
+      const closed = onClickOverlay && onClickOverlay(e);
+      closed && close();
+    }
+  };
+  const onHandleClick = (e) => {
+    onClick && onClick(e);
+  };
+  const onHandleClickCloseIcon = (e) => {
+    const closed = onClickCloseIcon && onClickCloseIcon(e);
+    closed && close();
+  };
+  const onHandleOpened = (e) => {
+    afterShow && afterShow();
+  };
+  const onHandleClosed = (e) => {
+    afterClose && afterClose();
+  };
+  const resolveContainer = (getContainer) => {
+    const container = typeof getContainer === "function" ? getContainer() : getContainer;
+    return container || document.body;
+  };
+  const renderToContainer = (getContainer, node) => {
+    if (getContainer) {
+      const container = resolveContainer(getContainer);
+      return createPortal(node, container);
+    }
+    return node;
+  };
+  const renderIcon = () => {
+    if (closeable) {
+      return React.createElement(View, { className: closeClasses, onClick: onHandleClickCloseIcon }, React.isValidElement(closeIcon) ? closeIcon : React.createElement(Close, { width: 12, height: 12 }));
+    }
+    return null;
+  };
+  const renderPop = () => {
+    return React.createElement(
+      CSSTransition,
+      { classNames: transitionName, unmountOnExit: true, timeout: 500, in: innerVisible, onEntered: onHandleOpened, onExited: onHandleClosed },
+      React.createElement(
+        View,
+        { style: popStyles, className: popClassName, onClick: onHandleClick },
+        showChildren ? children : "",
+        renderIcon()
+      )
+    );
+  };
+  const renderNode = () => {
+    return React.createElement(React.Fragment, null, overlay ? React.createElement(
+      React.Fragment,
+      null,
+      React.createElement(Overlay, { style: overlayStyles, className: overlayClassName, visible: innerVisible, closeOnOverlayClick, zIndex, lockScroll, duration, onClick: onHandleClickOverlay }),
+      renderPop()
+    ) : React.createElement(React.Fragment, null, renderPop()));
+  };
+  useEffect(() => {
+    visible && open();
+    !visible && close();
+  }, [visible]);
+  useEffect(() => {
+    setTransitionName(transition || `${classPrefix}-slide-${position}`);
+  }, [position, transition]);
+  return React.createElement(React.Fragment, null, renderToContainer(portal, renderNode()));
+};
+Popup.defaultProps = defaultProps;
+Popup.displayName = "NutPopup";
+export {
+  Popup as P
+};

package/dist/esm/price.taro-c4f45310.js

@@ -0,0 +1,80 @@
+import React from "react";
+import { c as cn } from "./bem-cdccae08.js";
+const defaultProps = {
+  price: 0,
+  needSymbol: true,
+  symbol: "¥",
+  decimalDigits: 2,
+  thousands: false,
+  position: "before",
+  size: "large",
+  className: ""
+};
+const Price = (props) => {
+  const { price, needSymbol, symbol, decimalDigits, thousands, position, size, className, ...rest } = {
+    ...defaultProps,
+    ...props
+  };
+  const b = cn("price");
+  const replaceSpecialChar = (url) => {
+    url = url.replace(/"/g, '"');
+    url = url.replace(/&/g, "&");
+    url = url.replace(/&lt;/g, "<");
+    url = url.replace(/&gt;/g, ">");
+    url = url.replace(/&nbsp;/g, " ");
+    url = url.replace(/&yen;/g, "￥");
+    return url;
+  };
+  const showSymbol = () => {
+    return { __html: needSymbol ? replaceSpecialChar(symbol) : "" };
+  };
+  const checkPoint = (price2) => {
+    return String(price2).indexOf(".") > 0;
+  };
+  const formatThousands = (num) => {
+    if (Number(num) === 0) {
+      num = 0;
+    }
+    if (checkPoint(num)) {
+      num = Number(num).toFixed(decimalDigits);
+      num = typeof num.split(".") === "string" ? num.split(".") : num.split(".")[0];
+    } else {
+      num = num.toString();
+    }
+    if (thousands) {
+      return (num || 0).toString().replace(/(\d)(?=(?:\d{3})+$)/g, "$1,");
+    }
+    return num;
+  };
+  const formatDecimal = (decimalNum) => {
+    if (Number(decimalNum) === 0) {
+      decimalNum = 0;
+    }
+    if (checkPoint(decimalNum)) {
+      decimalNum = Number(decimalNum).toFixed(decimalDigits);
+      decimalNum = typeof decimalNum.split(".") === "string" ? 0 : decimalNum.split(".")[1] || 0;
+    } else {
+      decimalNum = 0;
+    }
+    const result = `0.${decimalNum}`;
+    const resultFixed = Number(result).toFixed(decimalDigits);
+    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: `${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
+  );
+};
+Price.defaultProps = defaultProps;
+Price.displayName = "NutPrice";
+export {
+  Price as P
+};

package/dist/esm/progress.taro-ff63be75.js

@@ -0,0 +1,49 @@
+import React from "react";
+import classNames from "classnames";
+import { C as ComponentDefaults } from "./typings-11d83a22.js";
+const defaultProps = {
+  ...ComponentDefaults,
+  percent: 0,
+  showText: false,
+  animated: false
+};
+const Progress = (props) => {
+  const { className, style, percent, background, color, strokeWidth, showText, animated, children, ...rest } = {
+    ...defaultProps,
+    ...props
+  };
+  const classPrefix = "nut-progress";
+  const classesInner = classNames({
+    [`${classPrefix}-inner`]: true,
+    [`${classPrefix}-active`]: animated
+  });
+  const stylesOuter = {
+    height: `${strokeWidth}px`,
+    background
+  };
+  const stylesInner = {
+    width: `${percent}%`,
+    background: color
+  };
+  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(
+        "div",
+        { className: `${classPrefix}-text__inner`, style: {
+          background: color
+        } },
+        percent,
+        "%"
+      )))
+    )
+  );
+};
+Progress.defaultProps = defaultProps;
+Progress.displayName = "NutProgress";
+export {
+  Progress as P
+};

package/dist/esm/pulltorefresh.taro-c611fd92.js

@@ -0,0 +1,179 @@
+import React, { useState, useRef, useEffect } from "react";
+import { useDrag } from "@use-gesture/react";
+import { useSpring, animated } from "@react-spring/web";
+import { u as useConfig } from "./configprovider.taro-25758d9f.js";
+import { g as getScrollParent } from "./get-scroll-parent-8da04f2e.js";
+import { p as passiveSupported } from "./supports-passive-aaaf0eff.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 = {
+  pullingText: "",
+  canReleaseText: "",
+  refreshingText: "",
+  completeText: "",
+  completeDelay: 500,
+  disabled: false,
+  headHeight: 40,
+  threshold: 60,
+  onRefresh: () => {
+  }
+};
+const PullToRefresh = (p) => {
+  const { locale } = useConfig();
+  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 [status, setStatus] = useState("pulling");
+  const [springStyles, api] = useSpring(() => ({
+    from: { height: 0 },
+    config: {
+      tension: 300,
+      friction: 30,
+      clamp: true
+    }
+  }));
+  const elementRef = useRef(null);
+  const pullingRef = useRef(false);
+  useEffect(() => {
+    var _a;
+    (_a = elementRef.current) == null ? void 0 : _a.addEventListener("touchmove", () => {
+    });
+  }, []);
+  async function doRefresh() {
+    api.start({ height: headHeight });
+    setStatus("refreshing");
+    try {
+      await props.onRefresh();
+      setStatus("complete");
+    } catch (e) {
+      api.start({
+        to: async (next) => {
+          await next({ height: 0 });
+          setStatus("pulling");
+        }
+      });
+      throw e;
+    }
+    if (props.completeDelay > 0) {
+      await sleep(props.completeDelay);
+    }
+    api.start({
+      to: async (next) => {
+        await next({ height: 0 });
+        setStatus("pulling");
+      }
+    });
+  }
+  useDrag((state) => {
+    if (status === "refreshing" || status === "complete")
+      return;
+    const { event } = state;
+    if (state.last) {
+      pullingRef.current = false;
+      if (status === "canRelease") {
+        doRefresh();
+      } else {
+        api.start({ height: 0 });
+      }
+      return;
+    }
+    function getScrollTop(element) {
+      return "scrollTop" in element ? element.scrollTop : element.scrollY;
+    }
+    const [, y] = state.movement;
+    if (state.first && y > 0) {
+      const target = state.event.target;
+      if (!target || !(target instanceof Element))
+        return;
+      let scrollParent = getScrollParent(target);
+      while (true) {
+        if (!scrollParent)
+          return;
+        const scrollTop = getScrollTop(scrollParent);
+        if (scrollTop > 0) {
+          return;
+        }
+        if (scrollParent instanceof Window) {
+          break;
+        }
+        scrollParent = getScrollParent(scrollParent.parentNode);
+      }
+      pullingRef.current = true;
+    }
+    if (!pullingRef.current)
+      return;
+    if (event.cancelable) {
+      event.preventDefault();
+    }
+    event.stopPropagation();
+    const height = Math.max(rubberbandIfOutOfBounds(y, 0, 0, headHeight * 5, 0.5), 0);
+    api.start({ height });
+    setStatus(height > threshold ? "canRelease" : "pulling");
+  }, {
+    pointer: { touch: true },
+    axis: "y",
+    target: elementRef,
+    enabled: !props.disabled,
+    eventOptions: passiveSupported ? { passive: false } : false
+  });
+  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 "";
+  };
+  return React.createElement(
+    animated.div,
+    { ref: elementRef, className: "nut-pulltorefresh" },
+    React.createElement(
+      animated.div,
+      { style: springStyles, className: "nut-pulltorefresh-head" },
+      React.createElement("div", { className: "nut-pulltorefresh-head-content", style: { height: headHeight } }, renderStatusText())
+    ),
+    React.createElement("div", { className: "nut-pulltorefresh-content" }, props.children)
+  );
+};
+PullToRefresh.defaultProps = defaultProps;
+PullToRefresh.displayName = "NutPullToRefresh";
+export {
+  PullToRefresh as P
+};