@nutui/nutui 3.1.22 → 3.1.23-beta.0

package/dist/packages/_es/InputNumber.js

@@ -1,46 +1,165 @@
 /*!
-* @nutui/nutui v3.1.22 Fri Jun 24 2022 18:11:16 GMT+0800 (中国标准时间)
+* @nutui/nutui v3.1.23-beta.0 Mon Jun 27 2022 17:55:50 GMT+0800 (中国标准时间)
 * (c) 2022 @jdf2e.
 * Released under the MIT License.
 */
-import { computed as e, resolveComponent as u, openBlock as l, createElementBlock as t, normalizeClass as a, normalizeStyle as n, createVNode as r, createElementVNode as d } from "vue";
-import { c as i } from "./component.js";
-import { p as m } from "./pxCheck.js";
-import { _ as o } from "./plugin-vue_export-helper.js";
+import { computed, resolveComponent, openBlock, createElementBlock, normalizeClass, normalizeStyle, createVNode, createElementVNode } from "vue";
+import { c as createComponent } from "./component.js";
+import { p as pxCheck } from "./pxCheck.js";
+import { _ as _export_sfc } from "./plugin-vue_export-helper.js";
 import "../locale/lang";
-const { componentName: s, create: c } = i("inputnumber"), b = c({ props: { modelValue: { type: [Number, String], default: 0 }, inputWidth: { type: [Number, String], default: "" }, buttonSize: { type: [Number, String], default: "" }, min: { type: [Number, String], default: 1 }, max: { type: [Number, String], default: 9999 }, step: { type: [Number, String], default: 1 }, decimalPlaces: { type: [Number, String], default: 0 }, disabled: { type: Boolean, default: false }, readonly: { type: Boolean, default: false } }, emits: ["update:modelValue", "change", "blur", "focus", "reduce", "add", "overlimit"], setup(u2, { emit: l2 }) {
-  const t2 = e(() => ({ [s]: true, [`${s}--disabled`]: u2.disabled })), a2 = (e2, t3) => {
-    let a3 = Number(e2).toFixed(Number(u2.decimalPlaces));
-    l2("update:modelValue", a3, t3), l2("change", a3, t3);
-  }, n2 = (e2 = Number(u2.modelValue)) => e2 < Number(u2.max) && !u2.disabled, r2 = (e2 = Number(u2.modelValue)) => e2 > Number(u2.min) && !u2.disabled;
-  return { classes: t2, change: (e2) => {
-    const u3 = e2.target;
-    l2("update:modelValue", u3.valueAsNumber, e2);
-  }, blur: (e2) => {
-    if (u2.disabled)
-      return;
-    if (u2.readonly)
-      return;
-    let t3 = e2.target.valueAsNumber;
-    t3 < Number(u2.min) ? t3 = Number(u2.min) : t3 > Number(u2.max) && (t3 = Number(u2.max)), a2(t3, e2), l2("blur", e2);
-  }, focus: (e2) => {
-    u2.disabled || u2.readonly || l2("focus", e2);
-  }, add: (e2) => {
-    if (l2("add", e2), n2()) {
-      let l3 = Number(u2.modelValue) + Number(u2.step);
-      a2(l3, e2);
-    } else
-      l2("overlimit", e2, "add");
-  }, addAllow: n2, reduce: (e2) => {
-    if (l2("reduce", e2), r2()) {
-      let l3 = Number(u2.modelValue) - Number(u2.step);
-      a2(l3, e2);
-    } else
-      l2("overlimit", e2, "reduce");
-  }, reduceAllow: r2, pxCheck: m };
-} }), p = ["min", "max", "disabled", "readonly", "value"];
-var f = o(b, [["render", function(e2, i2, m2, o2, s2, c2) {
-  const b2 = u("nut-icon");
-  return l(), t("view", { class: a(e2.classes), style: n({ height: e2.pxCheck(e2.buttonSize) }) }, [r(b2, { name: "minus", class: a(["nut-inputnumber__icon", { "nut-inputnumber__icon--disabled": !e2.reduceAllow() }]), size: e2.buttonSize, onClick: e2.reduce }, null, 8, ["class", "size", "onClick"]), d("input", { type: "number", min: e2.min, max: e2.max, style: n({ width: e2.pxCheck(e2.inputWidth) }), disabled: e2.disabled, readonly: e2.readonly, value: e2.modelValue, onInput: i2[0] || (i2[0] = (...u2) => e2.change && e2.change(...u2)), onBlur: i2[1] || (i2[1] = (...u2) => e2.blur && e2.blur(...u2)), onFocus: i2[2] || (i2[2] = (...u2) => e2.focus && e2.focus(...u2)) }, null, 44, p), r(b2, { name: "plus", class: a(["nut-inputnumber__icon", { "nut-inputnumber__icon--disabled": !e2.addAllow() }]), size: e2.buttonSize, onClick: e2.add }, null, 8, ["class", "size", "onClick"])], 6);
-}]]);
-export { f as default };
+const { componentName, create } = createComponent("inputnumber");
+const _sfc_main = create({
+  props: {
+    modelValue: {
+      type: [Number, String],
+      default: 0
+    },
+    inputWidth: {
+      type: [Number, String],
+      default: ""
+    },
+    buttonSize: {
+      type: [Number, String],
+      default: ""
+    },
+    min: {
+      type: [Number, String],
+      default: 1
+    },
+    max: {
+      type: [Number, String],
+      default: 9999
+    },
+    step: {
+      type: [Number, String],
+      default: 1
+    },
+    decimalPlaces: {
+      type: [Number, String],
+      default: 0
+    },
+    disabled: {
+      type: Boolean,
+      default: false
+    },
+    readonly: {
+      type: Boolean,
+      default: false
+    }
+  },
+  emits: ["update:modelValue", "change", "blur", "focus", "reduce", "add", "overlimit"],
+  setup(props, { emit }) {
+    const classes = computed(() => {
+      const prefixCls = componentName;
+      return {
+        [prefixCls]: true,
+        [`${prefixCls}--disabled`]: props.disabled
+      };
+    });
+    const fixedDecimalPlaces = (v) => {
+      return Number(v).toFixed(Number(props.decimalPlaces));
+    };
+    const change = (event) => {
+      const input = event.target;
+      emit("update:modelValue", input.valueAsNumber, event);
+    };
+    const emitChange = (value, event) => {
+      let output_value = fixedDecimalPlaces(value);
+      emit("update:modelValue", output_value, event);
+      emit("change", output_value, event);
+    };
+    const addAllow = (value = Number(props.modelValue)) => {
+      return value < Number(props.max) && !props.disabled;
+    };
+    const reduceAllow = (value = Number(props.modelValue)) => {
+      return value > Number(props.min) && !props.disabled;
+    };
+    const reduce = (event) => {
+      emit("reduce", event);
+      if (reduceAllow()) {
+        let output_value = Number(props.modelValue) - Number(props.step);
+        emitChange(output_value, event);
+      } else {
+        emit("overlimit", event, "reduce");
+      }
+    };
+    const add = (event) => {
+      emit("add", event);
+      if (addAllow()) {
+        let output_value = Number(props.modelValue) + Number(props.step);
+        emitChange(output_value, event);
+      } else {
+        emit("overlimit", event, "add");
+      }
+    };
+    const focus = (event) => {
+      if (props.disabled)
+        return;
+      if (props.readonly)
+        return;
+      emit("focus", event);
+    };
+    const blur = (event) => {
+      if (props.disabled)
+        return;
+      if (props.readonly)
+        return;
+      const input = event.target;
+      let value = input.valueAsNumber;
+      if (value < Number(props.min)) {
+        value = Number(props.min);
+      } else if (value > Number(props.max)) {
+        value = Number(props.max);
+      }
+      emitChange(value, event);
+      emit("blur", event);
+    };
+    return {
+      classes,
+      change,
+      blur,
+      focus,
+      add,
+      addAllow,
+      reduce,
+      reduceAllow,
+      pxCheck
+    };
+  }
+});
+const _hoisted_1 = ["min", "max", "disabled", "readonly", "value"];
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_nut_icon = resolveComponent("nut-icon");
+  return openBlock(), createElementBlock("view", {
+    class: normalizeClass(_ctx.classes),
+    style: normalizeStyle({ height: _ctx.pxCheck(_ctx.buttonSize) })
+  }, [
+    createVNode(_component_nut_icon, {
+      name: "minus",
+      class: normalizeClass(["nut-inputnumber__icon", { "nut-inputnumber__icon--disabled": !_ctx.reduceAllow() }]),
+      size: _ctx.buttonSize,
+      onClick: _ctx.reduce
+    }, null, 8, ["class", "size", "onClick"]),
+    createElementVNode("input", {
+      type: "number",
+      min: _ctx.min,
+      max: _ctx.max,
+      style: normalizeStyle({ width: _ctx.pxCheck(_ctx.inputWidth) }),
+      disabled: _ctx.disabled,
+      readonly: _ctx.readonly,
+      value: _ctx.modelValue,
+      onInput: _cache[0] || (_cache[0] = (...args) => _ctx.change && _ctx.change(...args)),
+      onBlur: _cache[1] || (_cache[1] = (...args) => _ctx.blur && _ctx.blur(...args)),
+      onFocus: _cache[2] || (_cache[2] = (...args) => _ctx.focus && _ctx.focus(...args))
+    }, null, 44, _hoisted_1),
+    createVNode(_component_nut_icon, {
+      name: "plus",
+      class: normalizeClass(["nut-inputnumber__icon", { "nut-inputnumber__icon--disabled": !_ctx.addAllow() }]),
+      size: _ctx.buttonSize,
+      onClick: _ctx.add
+    }, null, 8, ["class", "size", "onClick"])
+  ], 6);
+}
+var index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export { index as default };

package/dist/packages/_es/Layout.js

@@ -1,10 +1,11 @@
 /*!
-* @nutui/nutui v3.1.22 Fri Jun 24 2022 18:11:16 GMT+0800 (中国标准时间)
+* @nutui/nutui v3.1.23-beta.0 Mon Jun 27 2022 17:55:50 GMT+0800 (中国标准时间)
 * (c) 2022 @jdf2e.
 * Released under the MIT License.
 */
-import { c as o } from "./component.js";
+import { c as createComponent } from "./component.js";
 import "vue";
 import "../locale/lang";
-const { create: t } = o("layout"), a = t({});
-export { a as default };
+const { create } = createComponent("layout");
+const _sfc_main = create({});
+export { _sfc_main as default };

package/dist/packages/_es/List.js

@@ -1,23 +1,111 @@
 /*!
-* @nutui/nutui v3.1.22 Fri Jun 24 2022 18:11:16 GMT+0800 (中国标准时间)
+* @nutui/nutui v3.1.23-beta.0 Mon Jun 27 2022 17:55:50 GMT+0800 (中国标准时间)
 * (c) 2022 @jdf2e.
 * Released under the MIT License.
 */
-import { ref as t, reactive as e, computed as l, watch as s, toRefs as i, openBlock as a, createElementBlock as r, normalizeClass as n, createElementVNode as o, normalizeStyle as c, Fragment as h, renderList as m, renderSlot as u } from "vue";
-import { c as g } from "./component.js";
-import { _ as p } from "./plugin-vue_export-helper.js";
+import { ref, reactive, computed, watch, toRefs, openBlock, createElementBlock, normalizeClass, createElementVNode, normalizeStyle, Fragment, renderList, renderSlot } from "vue";
+import { c as createComponent } from "./component.js";
+import { _ as _export_sfc } from "./plugin-vue_export-helper.js";
 import "../locale/lang";
-const { componentName: f, create: d } = g("list");
-var v = p(d({ props: { height: { type: [Number], default: 50 }, listData: { type: Array, default: () => [] }, containerHeight: { type: [Number], default: document.documentElement.clientHeight || document.body.clientHeight || 667 } }, emits: ["scroll", "scroll-bottom"], setup(a2, { emit: r2 }) {
-  const n2 = t(null), o2 = e({ startOffset: 0, start: 0, list: a2.listData.slice() }), c2 = l(() => Math.ceil(a2.containerHeight / a2.height)), h2 = l(() => o2.start + c2.value), m2 = l(() => `translate3d(0, ${o2.startOffset}px, 0)`), u2 = l(() => ({ [f]: true })), g2 = l(() => o2.list.length * a2.height), p2 = l(() => o2.list.slice(o2.start, Math.min(h2.value, o2.list.length)));
-  return s(() => a2.listData, () => {
-    o2.list = a2.listData.slice();
-  }), { ...i(o2), list: n2, getTransform: m2, listHeight: g2, visibleData: p2, classes: u2, handleScrollEvent: () => {
-    var _a;
-    const t2 = (_a = n2.value) == null ? void 0 : _a.scrollTop;
-    o2.start = Math.floor(t2 / a2.height), h2.value > o2.list.length && (r2("scroll"), r2("scroll-bottom")), o2.startOffset = t2 - t2 % a2.height;
-  } };
-} }), [["render", function(t2, e2, l2, s2, i2, g2) {
-  return a(), r("view", { class: n(t2.classes), onScrollPassive: e2[0] || (e2[0] = (...e3) => t2.handleScrollEvent && t2.handleScrollEvent(...e3)), ref: "list" }, [o("div", { class: "nut-list-phantom", style: c({ height: t2.listHeight + "px" }) }, null, 4), o("div", { class: "nut-list-container", style: c({ transform: t2.getTransform }) }, [(a(true), r(h, null, m(t2.visibleData, (e3, l3) => (a(), r("div", { class: "nut-list-item", style: c({ height: t2.height + "px" }), key: e3 }, [u(t2.$slots, "default", { item: e3, index: l3 })], 4))), 128))], 4)], 34);
-}]]);
-export { v as default };
+const { componentName, create } = createComponent("list");
+const _sfc_main = create({
+  props: {
+    height: {
+      type: [Number],
+      default: 50
+    },
+    listData: {
+      type: Array,
+      default: () => {
+        return [];
+      }
+    },
+    containerHeight: {
+      type: [Number],
+      default: document.documentElement.clientHeight || document.body.clientHeight || 667
+    }
+  },
+  emits: ["scroll", "scroll-bottom"],
+  setup(props, { emit }) {
+    const list = ref(null);
+    const state = reactive({
+      startOffset: 0,
+      start: 0,
+      list: props.listData.slice()
+    });
+    const visibleCount = computed(() => {
+      return Math.ceil(props.containerHeight / props.height);
+    });
+    const end = computed(() => {
+      return state.start + visibleCount.value;
+    });
+    const getTransform = computed(() => {
+      return `translate3d(0, ${state.startOffset}px, 0)`;
+    });
+    const classes = computed(() => {
+      const prefixCls = componentName;
+      return {
+        [prefixCls]: true
+      };
+    });
+    const listHeight = computed(() => {
+      return state.list.length * props.height;
+    });
+    const visibleData = computed(() => {
+      return state.list.slice(state.start, Math.min(end.value, state.list.length));
+    });
+    const handleScrollEvent = () => {
+      var _a;
+      const scrollTop = (_a = list.value) == null ? void 0 : _a.scrollTop;
+      state.start = Math.floor(scrollTop / props.height);
+      if (end.value > state.list.length) {
+        emit("scroll");
+        emit("scroll-bottom");
+      }
+      state.startOffset = scrollTop - scrollTop % props.height;
+    };
+    watch(() => props.listData, () => {
+      state.list = props.listData.slice();
+    });
+    return {
+      ...toRefs(state),
+      list,
+      getTransform,
+      listHeight,
+      visibleData,
+      classes,
+      handleScrollEvent
+    };
+  }
+});
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock("view", {
+    class: normalizeClass(_ctx.classes),
+    onScrollPassive: _cache[0] || (_cache[0] = (...args) => _ctx.handleScrollEvent && _ctx.handleScrollEvent(...args)),
+    ref: "list"
+  }, [
+    createElementVNode("div", {
+      class: "nut-list-phantom",
+      style: normalizeStyle({ height: _ctx.listHeight + "px" })
+    }, null, 4),
+    createElementVNode("div", {
+      class: "nut-list-container",
+      style: normalizeStyle({ transform: _ctx.getTransform })
+    }, [
+      (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.visibleData, (item, index2) => {
+        return openBlock(), createElementBlock("div", {
+          class: "nut-list-item",
+          style: normalizeStyle({ height: _ctx.height + "px" }),
+          key: item
+        }, [
+          renderSlot(_ctx.$slots, "default", {
+            item,
+            index: index2
+          })
+        ], 4);
+      }), 128))
+    ], 4)
+  ], 34);
+}
+var index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export { index as default };

package/dist/packages/_es/Menu.js

@@ -1,51 +1,175 @@
 /*!
-* @nutui/nutui v3.1.22 Fri Jun 24 2022 18:11:16 GMT+0800 (中国标准时间)
+* @nutui/nutui v3.1.23-beta.0 Mon Jun 27 2022 17:55:50 GMT+0800 (中国标准时间)
 * (c) 2022 @jdf2e.
 * Released under the MIT License.
 */
-import { ref as e, computed as t, onMounted as o, onUnmounted as l, reactive as n, provide as s, resolveComponent as r, openBlock as i, createElementBlock as a, normalizeClass as c, createElementVNode as u, Fragment as d, renderList as p, normalizeStyle as m, toDisplayString as f, createVNode as v, renderSlot as w } from "vue";
-import { c as g } from "./component.js";
-import { u as h } from "./index2.js";
-import { _ as y } from "./plugin-vue_export-helper.js";
+import { ref, computed, onMounted, onUnmounted, reactive, provide, resolveComponent, openBlock, createElementBlock, normalizeClass, createElementVNode, Fragment, renderList, normalizeStyle, toDisplayString, createVNode, renderSlot } from "vue";
+import { c as createComponent } from "./component.js";
+import { u as useRect } from "./index2.js";
+import { _ as _export_sfc } from "./plugin-vue_export-helper.js";
 import "../locale/lang";
-const { componentName: b, create: x } = g("menu"), C = x({ props: { activeColor: { type: String, default: "" }, overlay: { type: Boolean, default: true }, lockScroll: { type: Boolean, default: true }, duration: { type: [Number, String], default: 0 }, closeOnClickOverlay: { type: Boolean, default: true }, direction: { type: String, default: "down" }, scrollFixed: { type: [Boolean, String, Number], default: false }, titleClass: [String] }, setup(r2, { emit: i2, slots: a2 }) {
-  const c2 = e(), u2 = e(0), d2 = e(false), { children: p2, linkChildren: m2 } = (() => {
-    const e2 = n([]), t2 = n([]);
-    return { children: e2, linkChildren: (o2) => {
-      s("menuParent", Object.assign({ link: (o3) => {
-        o3.proxy && (t2.push(o3), e2.push(o3.proxy));
-      }, children: e2, internalChildren: t2 }, o2));
-    } };
-  })(), f2 = t(() => p2.some((e2) => e2.state.showWrapper)), v2 = t(() => ({ [b]: true, "scroll-fixed": d2.value }));
-  m2({ props: r2, offset: u2 });
-  const w2 = () => {
-    const { scrollFixed: e2 } = r2, t2 = (o2 = window, Math.max(0, "scrollTop" in o2 ? o2.scrollTop : o2.pageYOffset));
-    var o2;
-    d2.value = t2 > (typeof e2 == "boolean" ? 30 : Number(e2));
-  };
-  return o(() => {
-    const { scrollFixed: e2 } = r2;
-    e2 && window.addEventListener("scroll", w2);
-  }), l(() => {
-    const { scrollFixed: e2 } = r2;
-    e2 && window.removeEventListener("scroll", w2);
-  }), { toggleItem: (e2) => {
-    p2.forEach((t2, o2) => {
-      o2 === e2 ? ((() => {
-        if (c2.value) {
-          const e3 = h(c2);
-          r2.direction === "down" ? u2.value = e3.bottom : u2.value = window.innerHeight - e3.top;
+const { componentName, create } = createComponent("menu");
+const _sfc_main = create({
+  props: {
+    activeColor: {
+      type: String,
+      default: ""
+    },
+    overlay: {
+      type: Boolean,
+      default: true
+    },
+    lockScroll: {
+      type: Boolean,
+      default: true
+    },
+    duration: {
+      type: [Number, String],
+      default: 0
+    },
+    closeOnClickOverlay: {
+      type: Boolean,
+      default: true
+    },
+    direction: {
+      type: String,
+      default: "down"
+    },
+    scrollFixed: {
+      type: [Boolean, String, Number],
+      default: false
+    },
+    titleClass: [String]
+  },
+  setup(props, { emit, slots }) {
+    const barRef = ref();
+    const offset = ref(0);
+    const isScrollFixed = ref(false);
+    const useChildren = () => {
+      const publicChildren = reactive([]);
+      const internalChildren = reactive([]);
+      const linkChildren2 = (value) => {
+        const link = (child) => {
+          if (child.proxy) {
+            internalChildren.push(child);
+            publicChildren.push(child.proxy);
+          }
+        };
+        provide("menuParent", Object.assign({
+          link,
+          children: publicChildren,
+          internalChildren
+        }, value));
+      };
+      return {
+        children: publicChildren,
+        linkChildren: linkChildren2
+      };
+    };
+    const { children, linkChildren } = useChildren();
+    const opened = computed(() => children.some((item) => item.state.showWrapper));
+    const classes = computed(() => {
+      const prefixCls = componentName;
+      return {
+        [prefixCls]: true,
+        "scroll-fixed": isScrollFixed.value
+      };
+    });
+    const updateOffset = () => {
+      if (barRef.value) {
+        const rect = useRect(barRef);
+        if (props.direction === "down") {
+          offset.value = rect.bottom;
+        } else {
+          offset.value = window.innerHeight - rect.top;
+        }
+      }
+    };
+    linkChildren({ props, offset });
+    const toggleItem = (active) => {
+      children.forEach((item, index2) => {
+        if (index2 === active) {
+          updateOffset();
+          item.toggle();
+        } else if (item.state.showPopup) {
+          item.toggle(false, { immediate: true });
         }
-      })(), t2.toggle()) : t2.state.showPopup && t2.toggle(false, { immediate: true });
+      });
+    };
+    const getScrollTop = (el) => {
+      return Math.max(0, "scrollTop" in el ? el.scrollTop : el.pageYOffset);
+    };
+    const onScroll = () => {
+      const { scrollFixed } = props;
+      const scrollTop = getScrollTop(window);
+      isScrollFixed.value = scrollTop > (typeof scrollFixed === "boolean" ? 30 : Number(scrollFixed));
+    };
+    const getClasses = (showPopup) => {
+      let str = "";
+      const { titleClass } = props;
+      if (showPopup) {
+        str += "active";
+      }
+      if (titleClass) {
+        str += ` ${titleClass}`;
+      }
+      return str;
+    };
+    onMounted(() => {
+      const { scrollFixed } = props;
+      if (scrollFixed) {
+        window.addEventListener("scroll", onScroll);
+      }
+    });
+    onUnmounted(() => {
+      const { scrollFixed } = props;
+      if (scrollFixed) {
+        window.removeEventListener("scroll", onScroll);
+      }
     });
-  }, children: p2, opened: f2, classes: v2, barRef: c2, getClasses: (e2) => {
-    let t2 = "";
-    const { titleClass: o2 } = r2;
-    return e2 && (t2 += "active"), o2 && (t2 += ` ${o2}`), t2;
-  } };
-} }), _ = ["onClick"], k = { class: "nut-menu__title-text" };
-var S = y(C, [["render", function(e2, t2, o2, l2, n2, s2) {
-  const g2 = r("nut-icon");
-  return i(), a("view", { class: c(e2.classes) }, [u("view", { class: c(["nut-menu__bar", { opened: e2.opened }]), ref: "barRef" }, [(i(true), a(d, null, p(e2.children, (t3, o3) => (i(), a("view", { key: o3, class: c(["nut-menu__item", { disabled: t3.disabled, active: t3.state.showPopup }]), onClick: (l3) => !t3.disabled && e2.toggleItem(o3), style: m({ color: t3.state.showPopup ? e2.activeColor : "" }) }, [u("view", { class: c(["nut-menu__title", e2.getClasses(t3.state.showPopup)]) }, [u("view", k, f(t3.renderTitle()), 1), v(g2, { name: t3.titleIcon || (e2.direction === "up" ? "arrow-up" : "down-arrow"), size: "10", class: "nut-menu__title-icon" }, null, 8, ["name"])], 2)], 14, _))), 128))], 2), w(e2.$slots, "default")], 2);
-}]]);
-export { S as default };
+    return {
+      toggleItem,
+      children,
+      opened,
+      classes,
+      barRef,
+      getClasses
+    };
+  }
+});
+const _hoisted_1 = ["onClick"];
+const _hoisted_2 = { class: "nut-menu__title-text" };
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_nut_icon = resolveComponent("nut-icon");
+  return openBlock(), createElementBlock("view", {
+    class: normalizeClass(_ctx.classes)
+  }, [
+    createElementVNode("view", {
+      class: normalizeClass(["nut-menu__bar", { opened: _ctx.opened }]),
+      ref: "barRef"
+    }, [
+      (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.children, (item, index2) => {
+        return openBlock(), createElementBlock("view", {
+          key: index2,
+          class: normalizeClass(["nut-menu__item", { disabled: item.disabled, active: item.state.showPopup }]),
+          onClick: ($event) => !item.disabled && _ctx.toggleItem(index2),
+          style: normalizeStyle({ color: item.state.showPopup ? _ctx.activeColor : "" })
+        }, [
+          createElementVNode("view", {
+            class: normalizeClass(["nut-menu__title", _ctx.getClasses(item.state.showPopup)])
+          }, [
+            createElementVNode("view", _hoisted_2, toDisplayString(item.renderTitle()), 1),
+            createVNode(_component_nut_icon, {
+              name: item.titleIcon || (_ctx.direction === "up" ? "arrow-up" : "down-arrow"),
+              size: "10",
+              class: "nut-menu__title-icon"
+            }, null, 8, ["name"])
+          ], 2)
+        ], 14, _hoisted_1);
+      }), 128))
+    ], 2),
+    renderSlot(_ctx.$slots, "default")
+  ], 2);
+}
+var index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export { index as default };