@nutui/nutui 3.1.0 → 3.1.2-3.beta-4

package/dist/packages/_es/Ellipsis.js

@@ -0,0 +1,206 @@
+/*!
+* @nutui/nutui v3.1.23.beta-4 Mon Jul 25 2022 22:38:45 GMT+0800 (中国标准时间)
+* (c) 2022 @jdf2e.
+* Released under the MIT License.
+*/
+import { ref, reactive, computed, watch, onMounted, toRefs, openBlock, createElementBlock, normalizeClass, toDisplayString, createCommentVNode, createTextVNode, withModifiers } from "vue";
+import { c as createComponent } from "./component.js";
+import { _ as _export_sfc } from "./plugin-vue_export-helper.js";
+import "../locale/lang";
+const { componentName, create } = createComponent("ellipsis");
+const _sfc_main = create({
+  props: {
+    content: {
+      type: String,
+      default: ""
+    },
+    direction: {
+      type: String,
+      default: "end"
+    },
+    rows: {
+      type: [Number, String],
+      default: 1
+    },
+    expandText: {
+      type: String,
+      default: ""
+    },
+    collapseText: {
+      type: String,
+      default: ""
+    },
+    symbol: {
+      type: String,
+      default: "..."
+    }
+  },
+  emits: ["click", "change"],
+  setup(props, { emit }) {
+    const root = ref(null);
+    let container = null;
+    let maxHeight = 0;
+    const ellipsis = ref();
+    const state = reactive({
+      exceeded: false,
+      expanded: false
+    });
+    const classes = computed(() => {
+      const prefixCls = componentName;
+      return {
+        [prefixCls]: true
+      };
+    });
+    watch(() => props.content, (newV, oldVal) => {
+      if (newV != oldVal) {
+        if (container) {
+          document.body.appendChild(container);
+        }
+        createContainer();
+      }
+    });
+    onMounted(() => {
+      createContainer();
+    });
+    const createContainer = () => {
+      if (!root.value)
+        return;
+      const originStyle = window.getComputedStyle(root.value);
+      container = document.createElement("div");
+      const styleNames = Array.prototype.slice.apply(originStyle);
+      styleNames.forEach((name) => {
+        container.style.setProperty(name, originStyle.getPropertyValue(name));
+      });
+      container.style.position = "fixed";
+      container.style.left = "999999px";
+      container.style.top = "999999px";
+      container.style.zIndex = "-1000";
+      container.style.height = "auto";
+      container.style.minHeight = "auto";
+      container.style.maxHeight = "auto";
+      container.style.textOverflow = "clip";
+      container.style.whiteSpace = "normal";
+      container.style.webkitLineClamp = "unset";
+      container.style.display = "block";
+      const lineHeight = pxToNumber(originStyle.lineHeight);
+      maxHeight = Math.floor(lineHeight * (Number(props.rows) + 0.5) + pxToNumber(originStyle.paddingTop) + pxToNumber(originStyle.paddingBottom));
+      container.innerText = props.content;
+      document.body.appendChild(container);
+      calcEllipse();
+    };
+    const calcEllipse = () => {
+      if (container.offsetHeight <= maxHeight) {
+        state.exceeded = false;
+      } else {
+        state.exceeded = true;
+        const end = props.content.length;
+        const middle = Math.floor((0 + end) / 2);
+        const ellipsised = props.direction === "middle" ? tailorMiddle([0, middle], [middle, end]) : tailor(0, end);
+        ellipsis.value = ellipsised;
+        document.body.removeChild(container);
+      }
+    };
+    const tailor = (left, right) => {
+      const actionText = state.expanded ? props.collapseText : props.expandText;
+      const end = props.content.length;
+      if (right - left <= 1) {
+        if (props.direction === "end") {
+          return {
+            leading: props.content.slice(0, left) + props.symbol
+          };
+        } else {
+          return {
+            tailing: props.symbol + props.content.slice(right, end)
+          };
+        }
+      }
+      const middle = Math.round((left + right) / 2);
+      if (props.direction === "end") {
+        container.innerText = props.content.slice(0, middle) + props.symbol + actionText;
+      } else {
+        container.innerText = actionText + props.symbol + props.content.slice(middle, end);
+      }
+      if (container.offsetHeight <= maxHeight) {
+        if (props.direction === "end") {
+          return tailor(middle, right);
+        } else {
+          return tailor(left, middle);
+        }
+      } else {
+        if (props.direction === "end") {
+          return tailor(left, middle);
+        } else {
+          return tailor(middle, right);
+        }
+      }
+    };
+    const tailorMiddle = (leftPart, rightPart) => {
+      const actionText = state.expanded ? props.collapseText : props.expandText;
+      const end = props.content.length;
+      if (leftPart[1] - leftPart[0] <= 1 && rightPart[1] - rightPart[0] <= 1) {
+        return {
+          leading: props.content.slice(0, leftPart[0]) + props.symbol,
+          tailing: props.symbol + props.content.slice(rightPart[1], end)
+        };
+      }
+      const leftPartMiddle = Math.floor((leftPart[0] + leftPart[1]) / 2);
+      const rightPartMiddle = Math.ceil((rightPart[0] + rightPart[1]) / 2);
+      container.innerText = props.content.slice(0, leftPartMiddle) + props.symbol + actionText + props.symbol + props.content.slice(rightPartMiddle, end);
+      if (container.offsetHeight <= maxHeight) {
+        return tailorMiddle([leftPartMiddle, leftPart[1]], [rightPart[0], rightPartMiddle]);
+      } else {
+        return tailorMiddle([leftPart[0], leftPartMiddle], [rightPartMiddle, rightPart[1]]);
+      }
+    };
+    const pxToNumber = (value) => {
+      if (!value)
+        return 0;
+      const match = value.match(/^\d*(\.\d*)?/);
+      return match ? Number(match[0]) : 0;
+    };
+    const clickHandle = (type) => {
+      if (type == 1) {
+        state.expanded = true;
+        emit("change", "expand");
+      } else {
+        state.expanded = false;
+        emit("change", "collapse");
+      }
+    };
+    const handleClick = () => {
+      emit("click");
+    };
+    return { ...toRefs(state), root, ellipsis, classes, clickHandle, handleClick };
+  }
+});
+const _hoisted_1 = { key: 0 };
+const _hoisted_2 = { key: 1 };
+const _hoisted_3 = { key: 2 };
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock("view", {
+    class: normalizeClass(_ctx.classes),
+    onClick: _cache[2] || (_cache[2] = (...args) => _ctx.handleClick && _ctx.handleClick(...args)),
+    ref: "root"
+  }, [
+    !_ctx.exceeded ? (openBlock(), createElementBlock("view", _hoisted_1, toDisplayString(_ctx.content), 1)) : createCommentVNode("", true),
+    _ctx.exceeded && !_ctx.expanded ? (openBlock(), createElementBlock("view", _hoisted_2, [
+      createTextVNode(toDisplayString(_ctx.ellipsis.leading), 1),
+      _ctx.expandText ? (openBlock(), createElementBlock("span", {
+        key: 0,
+        class: "nut-ellipsis-text",
+        onClick: _cache[0] || (_cache[0] = withModifiers(($event) => _ctx.clickHandle(1), ["stop"]))
+      }, toDisplayString(_ctx.expandText), 1)) : createCommentVNode("", true),
+      createTextVNode(toDisplayString(_ctx.ellipsis.tailing), 1)
+    ])) : createCommentVNode("", true),
+    _ctx.exceeded && _ctx.expanded ? (openBlock(), createElementBlock("view", _hoisted_3, [
+      createTextVNode(toDisplayString(_ctx.content) + " ", 1),
+      _ctx.expandText ? (openBlock(), createElementBlock("span", {
+        key: 0,
+        class: "nut-ellipsis-text",
+        onClick: _cache[1] || (_cache[1] = withModifiers(($event) => _ctx.clickHandle(2), ["stop"]))
+      }, toDisplayString(_ctx.collapseText), 1)) : createCommentVNode("", true)
+    ])) : createCommentVNode("", true)
+  ], 2);
+}
+var index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export { index as default };

package/dist/packages/_es/Empty.js

@@ -0,0 +1,76 @@
+/*!
+* @nutui/nutui v3.1.23.beta-4 Mon Jul 25 2022 22:38:45 GMT+0800 (中国标准时间)
+* (c) 2022 @jdf2e.
+* Released under the MIT License.
+*/
+import { toRefs, computed, openBlock, createElementBlock, createElementVNode, normalizeStyle, renderSlot, Fragment, createCommentVNode, toDisplayString } from "vue";
+import { c as createComponent } from "./component.js";
+import { _ as _export_sfc } from "./plugin-vue_export-helper.js";
+import "../locale/lang";
+const { componentName, create, translate } = createComponent("empty");
+const defaultStatus = {
+  empty: "https://static-ftcms.jd.com/p/files/61a9e3183985005b3958672b.png",
+  error: "https://ftcms.jd.com/p/files/61a9e33ee7dcdbcc0ce62736.png",
+  network: "https://static-ftcms.jd.com/p/files/61a9e31de7dcdbcc0ce62734.png"
+};
+const _sfc_main = create({
+  props: {
+    image: {
+      type: String,
+      default: "empty"
+    },
+    imageSize: {
+      type: [Number, String],
+      default: ""
+    },
+    description: {
+      type: String,
+      default: ""
+    }
+  },
+  setup(props) {
+    const { image, imageSize } = toRefs(props);
+    const imgStyle = computed(() => {
+      if (!imageSize.value) {
+        return "";
+      }
+      if (typeof imageSize.value === "number") {
+        return `width:${imageSize.value}px;height:${imageSize.value}px`;
+      }
+      return `width:${imageSize.value};height:${imageSize.value}`;
+    });
+    const isHttpUrl = image.value.startsWith("https://") || image.value.startsWith("http://") || image.value.startsWith("//");
+    const imageUrl = isHttpUrl ? image.value : defaultStatus[image.value];
+    return {
+      imageUrl,
+      imgStyle,
+      translate
+    };
+  }
+});
+const _hoisted_1 = { class: "nut-empty" };
+const _hoisted_2 = ["src"];
+const _hoisted_3 = {
+  key: 1,
+  class: "nut-empty-description"
+};
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock("view", _hoisted_1, [
+    createElementVNode("view", {
+      class: "nut-empty-image",
+      style: normalizeStyle(_ctx.imgStyle)
+    }, [
+      _ctx.$slots.image ? renderSlot(_ctx.$slots, "image", { key: 0 }) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
+        _ctx.imageUrl ? (openBlock(), createElementBlock("img", {
+          key: 0,
+          class: "img",
+          src: _ctx.imageUrl
+        }, null, 8, _hoisted_2)) : createCommentVNode("", true)
+      ], 64))
+    ], 4),
+    _ctx.$slots.description ? renderSlot(_ctx.$slots, "description", { key: 0 }) : (openBlock(), createElementBlock("view", _hoisted_3, toDisplayString(_ctx.description || _ctx.translate("noData")), 1)),
+    _ctx.$slots.default ? renderSlot(_ctx.$slots, "default", { key: 2 }) : createCommentVNode("", true)
+  ]);
+}
+var index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export { index as default };

package/dist/packages/_es/FixedNav.js

@@ -0,0 +1,127 @@
+/*!
+* @nutui/nutui v3.1.23.beta-4 Mon Jul 25 2022 22:38:45 GMT+0800 (中国标准时间)
+* (c) 2022 @jdf2e.
+* Released under the MIT License.
+*/
+import { computed, resolveComponent, openBlock, createElementBlock, normalizeClass, normalizeStyle, createBlock, createCommentVNode, renderSlot, createElementVNode, Fragment, renderList, toDisplayString, createVNode } from "vue";
+import { c as createComponent } from "./component.js";
+import overlay from "./OverLay.js";
+import { _ as _export_sfc } from "./plugin-vue_export-helper.js";
+import "../locale/lang";
+const { componentName, create, translate } = createComponent("fixednav");
+const _sfc_main = create({
+  components: {
+    [overlay.name]: overlay
+  },
+  props: {
+    visible: {
+      type: Boolean,
+      default: false
+    },
+    overlay: {
+      type: Boolean,
+      default: true
+    },
+    navList: {
+      default: () => [],
+      type: Array
+    },
+    activeText: {
+      default: "",
+      type: String
+    },
+    unActiveText: {
+      default: "",
+      type: String
+    },
+    position: {
+      default: () => {
+        return {
+          top: "auto",
+          bottom: "auto"
+        };
+      },
+      type: Object
+    },
+    type: {
+      default: "right",
+      type: String
+    }
+  },
+  emits: ["update:visible", "selected"],
+  setup(props, { emit }) {
+    const classes = computed(() => {
+      const prefixCls = componentName;
+      return {
+        [prefixCls]: true,
+        active: props.visible,
+        [props.type]: true
+      };
+    });
+    const updateValue = (value = !props.visible) => {
+      emit("update:visible", value);
+    };
+    const selected = (item, event) => {
+      emit("selected", {
+        item,
+        event
+      });
+    };
+    return { classes, updateValue, selected, translate };
+  }
+});
+const _hoisted_1 = { class: "nut-fixednav__list" };
+const _hoisted_2 = ["onClick"];
+const _hoisted_3 = ["src"];
+const _hoisted_4 = { class: "span" };
+const _hoisted_5 = {
+  key: 0,
+  class: "b"
+};
+const _hoisted_6 = { class: "text" };
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_nut_overlay = resolveComponent("nut-overlay");
+  const _component_nut_icon = resolveComponent("nut-icon");
+  return openBlock(), createElementBlock("view", {
+    class: normalizeClass(_ctx.classes),
+    style: normalizeStyle(_ctx.position)
+  }, [
+    _ctx.overlay ? (openBlock(), createBlock(_component_nut_overlay, {
+      key: 0,
+      visible: _ctx.visible,
+      "z-index": 200,
+      onClick: _cache[0] || (_cache[0] = ($event) => _ctx.updateValue(false))
+    }, null, 8, ["visible"])) : createCommentVNode("", true),
+    renderSlot(_ctx.$slots, "list", {}, () => [
+      createElementVNode("view", _hoisted_1, [
+        (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.navList, (item, index2) => {
+          return openBlock(), createElementBlock("view", {
+            class: "nut-fixednav__list-item",
+            onClick: ($event) => _ctx.selected(item, $event),
+            key: item.id || index2
+          }, [
+            createElementVNode("img", {
+              src: item.icon
+            }, null, 8, _hoisted_3),
+            createElementVNode("view", _hoisted_4, toDisplayString(item.text), 1),
+            item.num ? (openBlock(), createElementBlock("view", _hoisted_5, toDisplayString(item.num), 1)) : createCommentVNode("", true)
+          ], 8, _hoisted_2);
+        }), 128))
+      ])
+    ]),
+    createElementVNode("div", {
+      class: "nut-fixednav__btn",
+      onClick: _cache[1] || (_cache[1] = ($event) => _ctx.updateValue())
+    }, [
+      renderSlot(_ctx.$slots, "btn", {}, () => [
+        createVNode(_component_nut_icon, {
+          name: "left",
+          color: "#fff"
+        }),
+        createElementVNode("view", _hoisted_6, toDisplayString(_ctx.visible ? _ctx.activeText || _ctx.translate("activeText") : _ctx.unActiveText || _ctx.translate("unActiveText")), 1)
+      ])
+    ])
+  ], 6);
+}
+var index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export { index as default };

package/dist/packages/_es/Form.js

@@ -0,0 +1,158 @@
+/*!
+* @nutui/nutui v3.1.23.beta-4 Mon Jul 25 2022 22:38:45 GMT+0800 (中国标准时间)
+* (c) 2022 @jdf2e.
+* Released under the MIT License.
+*/
+import { i as isObject, g as getPropByPath, a as isPromise, c as createComponent } from "./component.js";
+import { computed, reactive, provide, watch, resolveComponent, openBlock, createElementBlock, withModifiers, createVNode, withCtx, renderSlot } from "vue";
+import { _ as _export_sfc } from "./plugin-vue_export-helper.js";
+import "../locale/lang";
+const component = {
+  props: {
+    modelValue: {
+      type: Object,
+      default: {}
+    }
+  },
+  components: {},
+  emits: ["validate"],
+  setup(props, { emit, slots }) {
+    const formErrorTip = computed(() => reactive({}));
+    provide("formErrorTip", formErrorTip);
+    const clearErrorTips = (value = props.modelValue) => {
+      Object.keys(formErrorTip.value).forEach((item) => {
+        formErrorTip.value[item] = "";
+      });
+    };
+    const reset = () => {
+      clearErrorTips();
+    };
+    watch(() => props.modelValue, (value) => {
+      clearErrorTips(value);
+    }, { immediate: true });
+    const findFormItem = (vnodes) => {
+      let task = [];
+      vnodes.forEach((vnode, index2) => {
+        var _a, _b, _c, _d;
+        let type = vnode.type;
+        type = type.name || type;
+        if (type == "nut-form-item") {
+          task.push({
+            prop: (_a = vnode.props) == null ? void 0 : _a["prop"],
+            rules: ((_b = vnode.props) == null ? void 0 : _b["rules"]) || []
+          });
+        } else if (Array.isArray(vnode.children) && ((_c = vnode.children) == null ? void 0 : _c.length)) {
+          task = task.concat(findFormItem(vnode.children));
+        } else if (isObject(vnode.children) && Object.keys(vnode.children)) {
+          if ((_d = vnode.children) == null ? void 0 : _d.default) {
+            vnode.children = vnode.children.default();
+            task = task.concat(findFormItem(vnode.children));
+          }
+        }
+      });
+      return task;
+    };
+    const tipMessage = (errorMsg) => {
+      if (errorMsg.message) {
+        emit("validate", errorMsg);
+      }
+      formErrorTip.value[errorMsg.prop] = errorMsg.message;
+    };
+    const checkRule = (item) => {
+      const { rules, prop } = item;
+      const _Promise = (errorMsg) => {
+        return new Promise((resolve, reject) => {
+          tipMessage(errorMsg);
+          resolve(errorMsg);
+        });
+      };
+      if (!prop) {
+        console.warn("[NutUI] <FormItem> \u4F7F\u7528 rules \u6821\u9A8C\u89C4\u5219\u65F6 , \u5FC5\u987B\u8BBE\u7F6E prop \u53C2\u6570");
+      }
+      let value = getPropByPath(props.modelValue, prop || "");
+      tipMessage({ prop, message: "" });
+      let _rules = [...rules];
+      while (_rules.length) {
+        const { required, validator, regex, message } = _rules.shift();
+        const errorMsg = { prop, message };
+        if (required) {
+          if (!value) {
+            return _Promise(errorMsg);
+          }
+        }
+        if (regex && !regex.test(String(value))) {
+          return _Promise(errorMsg);
+        }
+        if (validator) {
+          const result = validator(value);
+          if (isPromise(result)) {
+            return new Promise((r, j) => {
+              result.then((res) => {
+                if (!res) {
+                  tipMessage(errorMsg);
+                  r(errorMsg);
+                } else {
+                  r(true);
+                }
+              });
+            });
+          } else {
+            if (!result) {
+              return _Promise(errorMsg);
+            }
+          }
+        }
+      }
+      return Promise.resolve(true);
+    };
+    const validate = (customProp = "") => {
+      return new Promise((resolve, reject) => {
+        let task = findFormItem(slots.default());
+        let errors = task.map((item) => {
+          if (customProp) {
+            if (customProp == item.prop) {
+              return checkRule(item);
+            } else {
+              return Promise.resolve(true);
+            }
+          } else {
+            return checkRule(item);
+          }
+        });
+        Promise.all(errors).then((errorRes) => {
+          errorRes = errorRes.filter((item) => item != true);
+          const res = { valid: true, errors: [] };
+          if (errorRes.length) {
+            res.valid = false;
+            res.errors = errorRes;
+          }
+          resolve(res);
+        });
+      });
+    };
+    const onSubmit = () => {
+      validate();
+      return false;
+    };
+    return { validate, reset, onSubmit, formErrorTip };
+  }
+};
+const { create } = createComponent("form");
+const _sfc_main = create(component);
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_nut_cell_group = resolveComponent("nut-cell-group");
+  return openBlock(), createElementBlock("form", {
+    class: "nut-form",
+    action: "#",
+    onSubmit: _cache[0] || (_cache[0] = withModifiers(() => false, ["prevent"]))
+  }, [
+    createVNode(_component_nut_cell_group, null, {
+      default: withCtx(() => [
+        renderSlot(_ctx.$slots, "default")
+      ]),
+      _: 3
+    })
+  ], 32);
+}
+var index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export { index as default };

package/dist/packages/_es/FormItem.js

@@ -0,0 +1,119 @@
+/*!
+* @nutui/nutui v3.1.23.beta-4 Mon Jul 25 2022 22:38:45 GMT+0800 (中国标准时间)
+* (c) 2022 @jdf2e.
+* Released under the MIT License.
+*/
+import { p as pxCheck } from "./pxCheck.js";
+import { inject, provide, computed, resolveComponent, openBlock, createBlock, normalizeClass, normalizeStyle, withCtx, createElementBlock, renderSlot, createTextVNode, toDisplayString, createCommentVNode, createElementVNode } from "vue";
+import { c as createComponent } from "./component.js";
+import { _ as _export_sfc } from "./plugin-vue_export-helper.js";
+import "../locale/lang";
+const { componentName, create } = createComponent("form-item");
+const _sfc_main = create({
+  inheritAttrs: false,
+  props: {
+    prop: {
+      type: String,
+      default: ""
+    },
+    label: {
+      type: String,
+      default: ""
+    },
+    rules: {
+      type: Array,
+      default: () => {
+        return [];
+      }
+    },
+    required: {
+      type: Boolean,
+      default: false
+    },
+    showErrorMessage: {
+      type: Boolean,
+      default: true
+    },
+    showErrorLine: {
+      type: Boolean,
+      default: true
+    },
+    labelWidth: {
+      type: [String, Number],
+      default: ""
+    },
+    labelAlign: {
+      type: String,
+      default: ""
+    },
+    errorMessageAlign: {
+      type: String,
+      default: ""
+    },
+    bodyAlign: {
+      type: String,
+      default: ""
+    }
+  },
+  components: {},
+  emits: [""],
+  setup(props, { emit }) {
+    const parent = inject("formErrorTip");
+    provide("form", {
+      props
+    });
+    const labelStyle = computed(() => {
+      return {
+        width: pxCheck(props.labelWidth),
+        textAlign: props.labelAlign
+      };
+    });
+    const bodyStyle = computed(() => {
+      return {
+        textAlign: props.bodyAlign
+      };
+    });
+    const errorMessageStyle = computed(() => {
+      return {
+        textAlign: props.errorMessageAlign
+      };
+    });
+    return { parent, labelStyle, bodyStyle, errorMessageStyle };
+  }
+});
+const _hoisted_1 = { class: "nut-cell__value nut-form-item__body" };
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_nut_cell = resolveComponent("nut-cell");
+  return openBlock(), createBlock(_component_nut_cell, {
+    class: normalizeClass(["nut-form-item", [{ error: _ctx.parent[_ctx.prop], line: _ctx.showErrorLine }, _ctx.$attrs.class]]),
+    style: normalizeStyle(_ctx.$attrs.style)
+  }, {
+    default: withCtx(() => [
+      _ctx.label ? (openBlock(), createElementBlock("view", {
+        key: 0,
+        class: normalizeClass(["nut-cell__title nut-form-item__label", { required: _ctx.required }]),
+        style: normalizeStyle(_ctx.labelStyle)
+      }, [
+        renderSlot(_ctx.$slots, "label", {}, () => [
+          createTextVNode(toDisplayString(_ctx.label), 1)
+        ])
+      ], 6)) : createCommentVNode("", true),
+      createElementVNode("view", _hoisted_1, [
+        createElementVNode("view", {
+          class: "nut-form-item__body__slots",
+          style: normalizeStyle(_ctx.bodyStyle)
+        }, [
+          renderSlot(_ctx.$slots, "default")
+        ], 4),
+        _ctx.parent[_ctx.prop] && _ctx.showErrorMessage ? (openBlock(), createElementBlock("view", {
+          key: 0,
+          class: "nut-form-item__body__tips",
+          style: normalizeStyle(_ctx.errorMessageStyle)
+        }, toDisplayString(_ctx.parent[_ctx.prop]), 5)) : createCommentVNode("", true)
+      ])
+    ]),
+    _: 3
+  }, 8, ["class", "style"]);
+}
+var index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export { index as default };

package/dist/packages/_es/Grid.js

@@ -0,0 +1,13 @@
+/*!
+* @nutui/nutui v3.1.23.beta-4 Mon Jul 25 2022 22:38:45 GMT+0800 (中国标准时间)
+* (c) 2022 @jdf2e.
+* Released under the MIT License.
+*/
+import { c as createComponent } from "./component.js";
+import { c as component } from "./common.js";
+import "vue";
+import "../locale/lang";
+import "./pxCheck.js";
+const { create } = createComponent("grid");
+const _sfc_main = create(component);
+export { _sfc_main as default };