npm - @nutui/nutui-react-taro - Versions diffs - 2.3.12 → 2.4.1-beta.0 - Mend

@nutui/nutui-react-taro 2.3.12 → 2.4.1-beta.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1169) hide show

package/dist/esm/cascader.taro-AZEBpBH3.js ADDED Viewed

@@ -0,0 +1,420 @@
+import { _ as __rest, a as __awaiter } from "./tslib.es6-BZ8i9Q6l.js";
+import React__default, { useState, useImperativeHandle, useEffect, isValidElement } from "react";
+import classNames from "classnames";
+import { Loading, Checklist } from "@nutui/icons-react-taro";
+import { ScrollView } from "@tarojs/components";
+import { P as Popup } from "./popup.taro-Iy_WQZ-m.js";
+import { T as Tabs } from "./tabs.taro-BxPmx5n5.js";
+import { C as ComponentDefaults } from "./typings-DV9RBfhj.js";
+import { u as usePropsValue } from "./use-props-value-SH9krhkx.js";
+const formatTree = (tree, parent, config) => tree.map((node) => {
+  const { value: valueKey = "value", text: textKey = "text", children: childrenKey = "children" } = config;
+  const _a = node, _b = valueKey, value = _a[_b], _c = textKey, text = _a[_c], _d = childrenKey, children = _a[_d], others = __rest(_a, [typeof _b === "symbol" ? _b : _b + "", typeof _c === "symbol" ? _c : _c + "", typeof _d === "symbol" ? _d : _d + ""]);
+  const newNode = Object.assign(Object.assign({ loading: false }, others), {
+    level: parent ? (parent && parent.level || 0) + 1 : 0,
+    value,
+    text,
+    children,
+    _parent: parent
+  });
+  if (newNode.children && newNode.children.length) {
+    newNode.children = formatTree(newNode.children, newNode, config);
+  }
+  return newNode;
+});
+const eachTree = (tree, cb) => {
+  let i = 0;
+  let node;
+  while (node = tree[i++]) {
+    if (cb(node) === true) {
+      break;
+    }
+    if (node.children && node.children.length) {
+      eachTree(node.children, cb);
+    }
+  }
+};
+const defaultConvertConfig = {
+  topId: null,
+  idKey: "id",
+  pidKey: "pid",
+  sortKey: ""
+};
+const convertListToOptions = (list, options) => {
+  const mergedOptions = Object.assign(Object.assign({}, defaultConvertConfig), options || {});
+  const { topId, idKey, pidKey, sortKey } = mergedOptions;
+  let result = [];
+  let map = {};
+  list.forEach((node) => {
+    node = Object.assign({}, node);
+    const { [idKey]: id, [pidKey]: pid } = node;
+    const children = map[pid] = map[pid] || [];
+    if (!result.length && pid === topId) {
+      result = children;
+    }
+    children.push(node);
+    node.children = map[id] || (map[id] = []);
+  });
+  if (sortKey) {
+    Object.keys(map).forEach((i) => {
+      if (map[i].length > 1) {
+        map[i].sort((a, b) => a[sortKey] - b[sortKey]);
+      }
+    });
+  }
+  map = null;
+  return result;
+};
+class Tree {
+  constructor(nodes, config) {
+    this.isLeaf = (node, lazy) => {
+      const { leaf, children } = node;
+      const hasChildren = Array.isArray(children) && Boolean(children.length);
+      return leaf || !hasChildren && !lazy;
+    };
+    this.hasChildren = (node, lazy) => {
+      const isLeaf = this.isLeaf(node, lazy);
+      if (isLeaf) {
+        return false;
+      }
+      const { children } = node;
+      return Array.isArray(children) && Boolean(children.length);
+    };
+    this.config = Object.assign({ value: "value", text: "text", children: "children" }, config || {});
+    this.nodes = formatTree(nodes, null, this.config);
+  }
+  updateChildren(nodes, parent) {
+    if (!parent) {
+      this.nodes = formatTree(nodes, null, this.config);
+    } else {
+      parent.children = formatTree(nodes, parent, this.config);
+    }
+  }
+  // for test
+  getNodeByValue(value) {
+    let foundNode;
+    eachTree(this.nodes, (node) => {
+      if (node.value === value) {
+        foundNode = node;
+        return true;
+      }
+      return null;
+    });
+    return foundNode;
+  }
+  getPathNodesByValue(value) {
+    if (!value.length) {
+      return [];
+    }
+    const pathNodes = [];
+    let currentNodes = this.nodes;
+    while (currentNodes && currentNodes.length) {
+      const foundNode = currentNodes.find((node) => node.value === value[node.level]);
+      if (!foundNode) {
+        break;
+      }
+      pathNodes.push(foundNode);
+      currentNodes = foundNode.children;
+    }
+    return pathNodes;
+  }
+}
+const defaultProps = Object.assign(Object.assign({}, ComponentDefaults), { activeColor: "", activeIcon: "checklist", popup: true, options: [], optionKey: { textKey: "text", valueKey: "value", childrenKey: "children" }, format: {}, closeable: false, closeIconPosition: "top-right", closeIcon: "close", lazy: false, onLoad: () => {
+}, onClose: () => {
+}, onChange: () => {
+}, onPathChange: () => {
+} });
+const InternalCascader = (props, ref) => {
+  const { className, style, activeColor, activeIcon, popup, popupProps = {}, visible, options, value, defaultValue, optionKey, format, closeable, closeIconPosition, closeIcon, lazy, onLoad, onClose, onChange, onPathChange } = Object.assign(Object.assign({}, defaultProps), props);
+  const [tabvalue, setTabvalue] = useState("c1");
+  const [optionsData, setOptionsData] = useState([]);
+  const isLazy = () => state.configs.lazy && Boolean(state.configs.onLoad);
+  const [innerValue, setInnerValue] = usePropsValue({
+    value,
+    defaultValue,
+    finalValue: defaultValue
+  });
+  const [innerVisible, setInnerVisible] = usePropsValue({
+    value: props.visible,
+    defaultValue: void 0,
+    finalValue: false
+  });
+  const actions = {
+    open: () => {
+      setInnerVisible(true);
+    },
+    close: () => {
+      setInnerVisible(false);
+    }
+  };
+  useImperativeHandle(ref, () => actions);
+  const [state] = useState({
+    optionsData: [],
+    panes: [
+      {
+        nodes: [],
+        selectedNode: [],
+        paneKey: ""
+      }
+    ],
+    tree: new Tree([], {}),
+    tabsCursor: 0,
+    // 选中的tab项
+    initLoading: false,
+    currentProcessNode: [],
+    configs: {
+      lazy,
+      onLoad,
+      optionKey,
+      format
+    },
+    lazyLoadMap: /* @__PURE__ */ new Map()
+  });
+  const classPrefix = classNames(`nut-cascader`);
+  const classesPane = classNames({
+    [`${classPrefix}-pane`]: true
+  });
+  useEffect(() => {
+    initData();
+  }, [options, format]);
+  const initData = () => __awaiter(void 0, void 0, void 0, function* () {
+    state.lazyLoadMap.clear();
+    if (format && Object.keys(format).length > 0) {
+      state.optionsData = convertListToOptions(options, format);
+    } else {
+      state.optionsData = options;
+    }
+    state.tree = new Tree(state.optionsData, {
+      value: state.configs.optionKey.valueKey,
+      text: state.configs.optionKey.textKey,
+      children: state.configs.optionKey.childrenKey
+    });
+    if (isLazy() && !state.tree.nodes.length) {
+      yield invokeLazyLoad({
+        root: true,
+        loading: true,
+        text: "",
+        value: ""
+      });
+    }
+    state.panes = [
+      {
+        nodes: state.tree.nodes,
+        selectedNode: null,
+        paneKey: "c1"
+      }
+    ];
+    syncValue();
+    setOptionsData(state.panes);
+  });
+  const syncValue = () => __awaiter(void 0, void 0, void 0, function* () {
+    const currentValue = innerValue;
+    if (currentValue === void 0 || currentValue !== defaultValue || !state.tree.nodes.length) {
+      return;
+    }
+    if (currentValue.length === 0) {
+      state.tabsCursor = 0;
+      return;
+    }
+    let needToSync = currentValue;
+    if (isLazy() && Array.isArray(currentValue) && currentValue.length) {
+      needToSync = [];
+      const parent = state.tree.nodes.find((node) => node.value === currentValue[0]);
+      if (parent) {
+        needToSync = [parent.value];
+        state.initLoading = true;
+        const last = yield currentValue.slice(1).reduce((p, value2) => __awaiter(void 0, void 0, void 0, function* () {
+          var _a;
+          const parent2 = yield p;
+          yield invokeLazyLoad(parent2);
+          const node = (_a = parent2 === null || parent2 === void 0 ? void 0 : parent2.children) === null || _a === void 0 ? void 0 : _a.find((item) => item.value === value2);
+          if (node) {
+            needToSync.push(value2);
+          }
+          return Promise.resolve(node);
+        }), Promise.resolve(parent));
+        yield invokeLazyLoad(last);
+        state.initLoading = false;
+      }
+    }
+    if (needToSync.length && currentValue === defaultValue) {
+      const pathNodes = state.tree.getPathNodesByValue(needToSync);
+      pathNodes.forEach((node, index) => {
+        state.tabsCursor = index;
+        chooseItem(node, true);
+      });
+    }
+  });
+  const invokeLazyLoad = (node) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!node) {
+      return;
+    }
+    if (!state.configs.onLoad) {
+      node.leaf = true;
+      return;
+    }
+    if (state.tree.isLeaf(node, isLazy()) || state.tree.hasChildren(node, isLazy())) {
+      return;
+    }
+    node.loading = true;
+    const parent = node.root ? null : node;
+    let lazyLoadPromise = state.lazyLoadMap.get(node);
+    if (!lazyLoadPromise) {
+      lazyLoadPromise = new Promise((resolve) => {
+        var _a, _b;
+        (_b = (_a = state.configs).onLoad) === null || _b === void 0 ? void 0 : _b.call(_a, node, resolve);
+      });
+      state.lazyLoadMap.set(node, lazyLoadPromise);
+    }
+    const nodes = yield lazyLoadPromise;
+    if (Array.isArray(nodes) && nodes.length > 0) {
+      state.tree.updateChildren(nodes, parent);
+    } else {
+      node.leaf = true;
+    }
+    node.loading = false;
+    state.lazyLoadMap.delete(node);
+  });
+  const close = () => {
+    setInnerVisible(false);
+    onClose && onClose();
+  };
+  const closePopup = () => {
+    close();
+  };
+  const chooseItem = (node, type) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!type && node.disabled || !state.panes[state.tabsCursor]) {
+      return;
+    }
+    if (state.tree.isLeaf(node, isLazy())) {
+      node.leaf = true;
+      state.panes[state.tabsCursor].selectedNode = node;
+      state.panes = state.panes.slice(0, node.level + 1);
+      if (!type) {
+        const pathNodes = state.panes.map((item) => item.selectedNode);
+        const optionParams = pathNodes.map((item) => item.value);
+        onChange(optionParams, pathNodes);
+        onPathChange(optionParams, pathNodes);
+        setInnerValue(optionParams);
+      }
+      setOptionsData(state.panes);
+      close();
+      return;
+    }
+    if (state.tree.hasChildren(node, isLazy())) {
+      const level = node.level + 1;
+      state.panes[state.tabsCursor].selectedNode = node;
+      state.panes = state.panes.slice(0, level);
+      state.tabsCursor = level;
+      state.panes.push({
+        nodes: node.children || [],
+        selectedNode: null,
+        paneKey: `c${state.tabsCursor + 1}`
+      });
+      setOptionsData(state.panes);
+      setTabvalue(`c${state.tabsCursor + 1}`);
+      if (!type) {
+        const pathNodes = state.panes.map((item) => item.selectedNode);
+        const optionParams = pathNodes.map((item) => item === null || item === void 0 ? void 0 : item.value);
+        onPathChange(optionParams, pathNodes);
+      }
+      return;
+    }
+    state.currentProcessNode = node;
+    if (node.loading) {
+      return;
+    }
+    yield invokeLazyLoad(node);
+    if (state.currentProcessNode === node) {
+      state.panes[state.tabsCursor].selectedNode = node;
+      chooseItem(node, type);
+    }
+    setOptionsData(state.panes);
+  });
+  const renderItem = (pane, node, index) => {
+    var _a;
+    const classPrefix2 = "nut-cascader-item";
+    const checked = ((_a = pane.selectedNode) === null || _a === void 0 ? void 0 : _a.value) === node.value;
+    const classes = classNames({
+      active: checked,
+      disabled: node.disabled
+    }, classPrefix2);
+    const classesTitle = classNames({
+      [`${classPrefix2}-title`]: true
+    });
+    const renderIcon = () => {
+      if (checked) {
+        if (isValidElement(activeIcon)) {
+          return activeIcon;
+        }
+        return React__default.createElement(Checklist, { className: `${checked ? `${classPrefix}-icon-check` : ""}` });
+      }
+      return null;
+    };
+    return React__default.createElement(
+      "div",
+      { style: { color: checked ? activeColor : "" }, className: classes, key: index, onClick: () => {
+        chooseItem(node, false);
+      } },
+      React__default.createElement("div", { className: classesTitle }, node.text),
+      node.loading ? React__default.createElement(Loading, { color: "#969799", className: "nut-cascader-item-icon-loading" }) : renderIcon()
+    );
+  };
+  const renderTabs = () => {
+    return React__default.createElement(
+      "div",
+      { className: `${classPrefix} ${className}`, style },
+      React__default.createElement(Tabs, { value: tabvalue, title: () => {
+        return optionsData.map((pane, index) => {
+          var _a, _b;
+          return React__default.createElement(
+            "div",
+            { onClick: () => {
+              setTabvalue(pane.paneKey);
+              state.tabsCursor = index;
+            }, className: `nut-tabs-titles-item ${tabvalue === pane.paneKey ? "nut-tabs-titles-item-active" : ""}`, key: pane.paneKey },
+            React__default.createElement(
+              "span",
+              { className: "nut-tabs-titles-item-text" },
+              !state.initLoading && state.panes.length && ((_a = pane === null || pane === void 0 ? void 0 : pane.selectedNode) === null || _a === void 0 ? void 0 : _a.text),
+              !state.initLoading && state.panes.length && !((_b = pane === null || pane === void 0 ? void 0 : pane.selectedNode) === null || _b === void 0 ? void 0 : _b.text) && "请选择",
+              !(!state.initLoading && state.panes.length) && "Loading..."
+            ),
+            React__default.createElement("span", { className: "nut-tabs-titles-item-line" })
+          );
+        });
+      } }, !state.initLoading && state.panes.length ? optionsData.map((pane) => {
+        var _a;
+        return React__default.createElement(
+          Tabs.TabPane,
+          { key: pane.paneKey, value: pane.paneKey },
+          React__default.createElement(ScrollView, { className: classesPane, scrollY: true }, (_a = pane.nodes) === null || _a === void 0 ? void 0 : _a.map((node, index) => renderItem(pane, node, index)))
+        );
+      }) : React__default.createElement(
+        Tabs.TabPane,
+        null,
+        React__default.createElement("div", { className: classesPane })
+      ))
+    );
+  };
+  return React__default.createElement(React__default.Fragment, null, popup ? React__default.createElement(Popup, Object.assign({}, popupProps, {
+    visible: innerVisible,
+    position: "bottom",
+    style: { overflowY: "hidden" },
+    round: true,
+    closeIcon,
+    closeable,
+    closeIconPosition,
+    title: popup && props.title,
+    left: props.left,
+    // todo 只关闭，不处理逻辑。和popup的逻辑不一致。关闭时需要增加是否要处理回调
+    onOverlayClick: closePopup,
+    onCloseIconClick: closePopup
+  }), renderTabs()) : renderTabs());
+};
+const Cascader = React__default.forwardRef(InternalCascader);
+Cascader.defaultProps = defaultProps;
+Cascader.displayName = "NutCascader";
+export {
+  Cascader as C
+};

package/dist/esm/checkbox.taro-CUpF7Afr.js ADDED Viewed

@@ -0,0 +1,222 @@
+import { _ as __rest } from "./tslib.es6-BZ8i9Q6l.js";
+import React__default, { createContext, useImperativeHandle, useCallback, useContext, useState, useEffect } from "react";
+import { CheckDisabled, Checked, CheckNormal } from "@nutui/icons-react-taro";
+import classNames from "classnames";
+import { View } from "@tarojs/components";
+import { C as ComponentDefaults } from "./typings-DV9RBfhj.js";
+import { u as usePropsValue } from "./use-props-value-SH9krhkx.js";
+const CheckboxGroupContext = createContext(null);
+const Context = CheckboxGroupContext;
+const defaultProps$1 = {
+  max: void 0,
+  min: void 0,
+  list: false,
+  labelPosition: "right",
+  direction: "vertical",
+  onChange: (value) => {
+  },
+  onLimit: (type) => {
+  },
+  options: []
+};
+const classPrefix$1 = "nut-checkboxgroup";
+const CheckboxGroup = React__default.forwardRef((props, ref) => {
+  const _a = Object.assign(Object.assign({}, defaultProps$1), props), { children, className, disabled, list, onChange, value, defaultValue, max, min, onLimit, labelPosition, direction, options } = _a, rest = __rest(_a, ["children", "className", "disabled", "list", "onChange", "value", "defaultValue", "max", "min", "onLimit", "labelPosition", "direction", "options"]);
+  useImperativeHandle(ref, () => ({
+    toggle(state) {
+      if (state === false) {
+        setValue([]);
+      } else {
+        const childrenLabel = [];
+        React__default.Children.map(children, (child) => {
+          const childProps = child.props;
+          childrenLabel.push(childProps.value);
+        });
+        setValue(childrenLabel);
+      }
+    },
+    reverse() {
+      const childrenLabel = [];
+      React__default.Children.map(children, (child) => {
+        const childProps = child.props;
+        childrenLabel.push(childProps.value);
+      });
+      const reverse = childrenLabel.filter((c) => (_value === null || _value === void 0 ? void 0 : _value.findIndex((v) => v === c)) === -1);
+      setValue(reverse);
+    }
+  }));
+  const [_value, setValue] = usePropsValue({
+    value: props.value,
+    defaultValue: props.defaultValue,
+    finalValue: [],
+    onChange
+  });
+  const renderOptions = useCallback(() => {
+    return options === null || options === void 0 ? void 0 : options.map((_a2) => {
+      var { label, value: value2, disabled: disabled2, onChange: onChange2 } = _a2, rest2 = __rest(_a2, ["label", "value", "disabled", "onChange"]);
+      return React__default.createElement(Checkbox, Object.assign({ key: value2 === null || value2 === void 0 ? void 0 : value2.toString(), label, disabled: disabled2, value: value2 }, rest2));
+    });
+  }, [options, max, min]);
+  return React__default.createElement(
+    Context.Provider,
+    { value: {
+      labelPosition: labelPosition || "right",
+      disabled,
+      max,
+      list,
+      onLimit,
+      value: _value,
+      check: (value2) => {
+        const combined = [..._value, value2];
+        if (max !== void 0) {
+          if (combined.length > max) {
+            return onLimit === null || onLimit === void 0 ? void 0 : onLimit("max");
+          }
+        }
+        setValue(combined);
+      },
+      uncheck: (value2) => {
+        const reduced = _value.filter((item) => item !== value2);
+        if (min !== void 0 && reduced.length < min) {
+          return onLimit === null || onLimit === void 0 ? void 0 : onLimit("min");
+        }
+        setValue(reduced);
+      }
+    } },
+    React__default.createElement("div", Object.assign({ className: classNames(classPrefix$1, {
+      [`nut-checkboxgroup-${props.direction}`]: props.direction,
+      [`nut-checkboxgroup-list`]: list
+    }, className) }, rest), (options === null || options === void 0 ? void 0 : options.length) ? renderOptions() : children)
+  );
+});
+CheckboxGroup.defaultProps = defaultProps$1;
+CheckboxGroup.displayName = "NutCheckboxGroup";
+const defaultProps = Object.assign(Object.assign({}, ComponentDefaults), { disabled: false, shape: "round", labelPosition: "right", icon: null, activeIcon: null, indeterminateIcon: null, onChange: (value) => {
+} });
+const classPrefix = "nut-checkbox";
+const Checkbox = (props) => {
+  const { children } = Object.assign(Object.assign({}, defaultProps), props);
+  const _a = props, { icon, label, className, activeIcon, checked, value, defaultChecked, shape, disabled, onChange, indeterminate, indeterminateIcon } = _a, others = __rest(_a, ["icon", "label", "className", "activeIcon", "checked", "value", "defaultChecked", "shape", "disabled", "onChange", "indeterminate", "indeterminateIcon"]);
+  let { labelPosition } = others, rest = __rest(others, ["labelPosition"]);
+  const ctx = useContext(Context);
+  let [innerChecked, setChecked] = usePropsValue({
+    value: props.checked,
+    defaultValue: props.defaultChecked,
+    finalValue: defaultChecked,
+    onChange
+  });
+  let [innerDisabled, setDisabled] = useState(disabled);
+  const [innerIndeterminate, setIndeterminate] = useState(indeterminate);
+  useEffect(() => {
+    setDisabled(disabled);
+  }, [disabled]);
+  useEffect(() => {
+    setIndeterminate(indeterminate);
+  }, [indeterminate]);
+  if (ctx) {
+    if (ctx.labelPosition !== void 0) {
+      labelPosition = ctx.labelPosition;
+    }
+    innerDisabled = ctx.disabled !== void 0 ? ctx.disabled : innerDisabled;
+    innerChecked = ctx.value.includes(value);
+    setChecked = (checked2) => {
+      if (ctx.disabled)
+        return;
+      if (checked2)
+        ctx.check(value);
+      if (!checked2)
+        ctx.uncheck(value);
+    };
+  }
+  const renderIcon = () => {
+    if (innerDisabled) {
+      if (innerIndeterminate) {
+        return React__default.createElement(CheckDisabled, { className: color() });
+      }
+      if (innerChecked) {
+        return React__default.createElement(Checked, { className: color() });
+      }
+      return React__default.createElement(CheckDisabled, { className: color() });
+    }
+    if (!innerChecked) {
+      return React__default.isValidElement(icon) ? icon : React__default.createElement(CheckNormal, { className: color() });
+    }
+    if (innerIndeterminate) {
+      return React__default.isValidElement(indeterminateIcon) ? indeterminateIcon : React__default.createElement(CheckDisabled, { className: color() });
+    }
+    return React__default.isValidElement(activeIcon) ? activeIcon : React__default.createElement(Checked, { className: color() });
+  };
+  const color = () => {
+    const cls = `${classPrefix}-icon `;
+    if (innerDisabled) {
+      if (innerChecked && !innerIndeterminate) {
+        return `${cls}${classPrefix}-icon-checked ${classPrefix}-icon-disabled`;
+      }
+      if (innerChecked && innerIndeterminate) {
+        return `${cls}${classPrefix}-icon-indeterminate ${classPrefix}-icon-disabled`;
+      }
+      return `${cls}${classPrefix}-icon-disabled`;
+    }
+    if (innerChecked) {
+      if (innerIndeterminate) {
+        return `${cls}${classPrefix}-icon-indeterminate`;
+      }
+      return `${cls}${classPrefix}-icon-checked`;
+    }
+    return cls;
+  };
+  const renderLabel = () => {
+    return React__default.createElement("span", { className: classNames(`${classPrefix}-label `, {
+      [`${classPrefix}-label-disabled`]: innerDisabled
+    }) }, children || label);
+  };
+  const handleClick = () => {
+    if (disabled)
+      return;
+    const latestChecked = !innerChecked;
+    setChecked(latestChecked);
+  };
+  const renderButton = () => {
+    return React__default.createElement(
+      View,
+      { className: classNames(`${classPrefix}-button`, {
+        [`${classPrefix}-button-active`]: innerChecked,
+        [`${classPrefix}-button-disabled`]: disabled
+      }) },
+      children || label,
+      innerChecked && activeIcon ? React__default.createElement(View, { className: classNames(`${classPrefix}-button-icon`) }, activeIcon) : null
+    );
+  };
+  const renderListItem = () => {
+    return React__default.createElement(
+      View,
+      { className: "nut-checkbox-list-item" },
+      renderLabel(),
+      renderIcon()
+    );
+  };
+  const renderCheckboxItem = () => {
+    if (ctx === null || ctx === void 0 ? void 0 : ctx.list) {
+      return React__default.createElement(React__default.Fragment, null, renderListItem());
+    }
+    if (shape === "button") {
+      return renderButton();
+    }
+    return React__default.createElement(
+      React__default.Fragment,
+      null,
+      renderIcon(),
+      renderLabel()
+    );
+  };
+  return React__default.createElement(View, Object.assign({ className: classNames(classPrefix, {
+    [`${classPrefix}-reverse`]: labelPosition === "left"
+  }, className) }, rest, { onClick: handleClick }), renderCheckboxItem());
+};
+Checkbox.defaultProps = defaultProps;
+Checkbox.displayName = "NutCheckBox";
+Checkbox.Group = CheckboxGroup;
+export {
+  Checkbox as C,
+  CheckboxGroup as a
+};