@nutui/nutui 4.0.11 → 4.0.12

package/dist/packages/_es/Cascader.js

@@ -1,137 +1,199 @@
-var le = Object.defineProperty, te = Object.defineProperties;
-var ne = Object.getOwnPropertyDescriptors;
-var w = Object.getOwnPropertySymbols;
-var H = Object.prototype.hasOwnProperty, U = Object.prototype.propertyIsEnumerable;
-var S = (e, l, a) => l in e ? le(e, l, { enumerable: !0, configurable: !0, writable: !0, value: a }) : e[l] = a, k = (e, l) => {
-  for (var a in l || (l = {}))
-    H.call(l, a) && S(e, a, l[a]);
-  if (w)
-    for (var a of w(l))
-      U.call(l, a) && S(e, a, l[a]);
-  return e;
-}, O = (e, l) => te(e, ne(l));
-var P = (e) => typeof e == "symbol" ? e : e + "", D = (e, l) => {
-  var a = {};
-  for (var n in e)
-    H.call(e, n) && l.indexOf(n) < 0 && (a[n] = e[n]);
-  if (e != null && w)
-    for (var n of w(e))
-      l.indexOf(n) < 0 && U.call(e, n) && (a[n] = e[n]);
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
   return a;
 };
-var E = (e, l, a) => (S(e, typeof l != "symbol" ? l + "" : l, a), a);
-var L = (e, l, a) => new Promise((n, r) => {
-  var u = (s) => {
-    try {
-      i(a.next(s));
-    } catch (c) {
-      r(c);
-    }
-  }, o = (s) => {
-    try {
-      i(a.throw(s));
-    } catch (c) {
-      r(c);
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __restKey = (key) => typeof key === "symbol" ? key : key + "";
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
     }
-  }, i = (s) => s.done ? n(s.value) : Promise.resolve(s.value).then(u, o);
-  i((a = a.apply(e, l)).next());
-});
-import { computed as I, ref as N, watch as T, resolveComponent as z, openBlock as g, createBlock as V, withCtx as _, createElementBlock as A, Fragment as q, renderList as G, createElementVNode as M, normalizeClass as oe, toDisplayString as ie, createCommentVNode as se, createVNode as re } from "vue";
-import { P as J, p as ue } from "./index-360c5092.js";
-import { c as Y } from "./component-234624bc.js";
-import { Loading as ce, Checklist as de } from "@nutui/icons-vue";
-import Q from "./Tabs.js";
-import R from "./TabPane.js";
-import { _ as Z } from "./_plugin-vue_export-helper-dad06003.js";
+  return target;
+};
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { computed, ref, watch, resolveComponent, openBlock, createBlock, withCtx, createElementBlock, Fragment, renderList, createElementVNode, normalizeClass, toDisplayString, createCommentVNode, createVNode } from "vue";
+import { P as Popup, p as popupProps } from "./index-da0a7662.js";
+import { c as createComponent } from "./component-81a4c1d0.js";
+import { Loading, Checklist } from "@nutui/icons-vue";
+import Tabs from "./Tabs.js";
+import TabPane from "./TabPane.js";
+import { _ as _export_sfc } from "./_plugin-vue_export-helper-cc2b3d55.js";
 import "./Overlay.js";
 import "../locale/lang";
-import "./pxCheck-38173291.js";
-import "./index-192a3ef6.js";
-import "./raf-a74f1a06.js";
-import "./index.vue_vue_type_script_lang-f44c159d.js";
-import "./index-53ec2d4d.js";
-const B = (e, l, a) => e.map((n) => {
-  const { value: r = "value", text: u = "text", children: o = "children" } = a, h = n, { [r]: i, [u]: s, [o]: c } = h, d = D(h, [P(r), P(u), P(o)]), y = O(k({
-    loading: !1
-  }, d), {
-    level: l ? (l && l.level || 0) + 1 : 0,
-    value: i,
-    text: s,
-    children: c,
-    _parent: l
+import "./pxCheck-c6b9f6b7.js";
+import "./index-29892cda.js";
+import "./raf-729dad54.js";
+import "./index.vue_vue_type_script_lang-cc5c4086.js";
+import "./index-7a7385e4.js";
+const formatTree = (tree, parent, config) => tree.map((node) => {
+  const { value: valueKey = "value", text: textKey = "text", children: childrenKey = "children" } = config;
+  const _a = node, { [valueKey]: value, [textKey]: text, [childrenKey]: children } = _a, others = __objRest(_a, [__restKey(valueKey), __restKey(textKey), __restKey(childrenKey)]);
+  const newNode = __spreadProps(__spreadValues({
+    loading: false
+  }, others), {
+    level: parent ? (parent && parent.level || 0) + 1 : 0,
+    value,
+    text,
+    children,
+    _parent: parent
   });
-  return y.children && y.children.length && (y.children = B(y.children, y, a)), y;
-}), x = (e, l) => {
-  let a = 0, n;
-  for (; (n = e[a++]) && l(n) !== !0; )
-    n.children && n.children.length && x(n.children, l);
-}, he = {
+  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: ""
-}, ve = (e, l) => {
-  const a = k(k({}, he), l || {}), { topId: n, idKey: r, pidKey: u, sortKey: o } = a;
-  let i = [], s = {};
-  return e.forEach((c) => {
-    c = k({}, c);
-    const { [r]: d, [u]: y } = c, h = s[y] = s[y] || [];
-    !i.length && y === n && (i = h), h.push(c), c.children = s[d] || (s[d] = []);
-  }), o && Object.keys(s).forEach((c) => {
-    s[c].length > 1 && s[c].sort((d, y) => d[o] - y[o]);
-  }), s = null, i;
 };
-class W {
-  constructor(l, a) {
-    E(this, "nodes");
-    E(this, "config");
-    this.config = k({
+const convertListToOptions = (list, options) => {
+  const mergedOptions = __spreadValues(__spreadValues({}, defaultConvertConfig), options || {});
+  const { topId, idKey, pidKey, sortKey } = mergedOptions;
+  let result = [];
+  let map = {};
+  list.forEach((node) => {
+    node = __spreadValues({}, 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) {
+    __publicField(this, "nodes");
+    __publicField(this, "config");
+    this.config = __spreadValues({
       value: "value",
       text: "text",
       children: "children"
-    }, a || {}), this.nodes = B(l, null, this.config);
+    }, config || {});
+    this.nodes = formatTree(nodes, null, this.config);
   }
-  updateChildren(l, a) {
-    a ? a.children = B(l, a, this.config) : this.nodes = B(l, 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(l) {
-    let a;
-    return x(this.nodes, (n) => {
-      if (n.value === l)
-        return a = n, !0;
-    }), a;
+  getNodeByValue(value) {
+    let foundNode;
+    eachTree(this.nodes, (node) => {
+      if (node.value === value) {
+        foundNode = node;
+        return true;
+      }
+    });
+    return foundNode;
   }
-  getPathNodesByValue(l) {
-    if (!l.length)
+  getPathNodesByValue(value) {
+    if (!value.length) {
       return [];
-    const a = [];
-    let n = this.nodes;
-    for (; n && n.length; ) {
-      const r = n.find((u) => u.value === l[u.level]);
-      if (!r)
+    }
+    const pathNodes = [];
+    let currentNodes = this.nodes;
+    while (currentNodes && currentNodes.length) {
+      const foundNode = currentNodes.find((node) => node.value === value[node.level]);
+      if (!foundNode) {
         break;
-      a.push(r), n = r.children;
+      }
+      pathNodes.push(foundNode);
+      currentNodes = foundNode.children;
     }
-    return a;
+    return pathNodes;
   }
-  isLeaf(l, a) {
-    const { leaf: n, children: r } = l, u = Array.isArray(r) && !!r.length;
-    return n || !u && !a;
+  isLeaf(node, lazy) {
+    const { leaf, children } = node;
+    const hasChildren = Array.isArray(children) && Boolean(children.length);
+    return leaf || !hasChildren && !lazy;
   }
-  hasChildren(l, a) {
-    if (this.isLeaf(l, a))
-      return !1;
-    const { children: r } = l;
-    return Array.isArray(r) && !!r.length;
+  hasChildren(node, lazy) {
+    const isLeaf = this.isLeaf(node, lazy);
+    if (isLeaf) {
+      return false;
+    }
+    const { children } = node;
+    return Array.isArray(children) && Boolean(children.length);
   }
 }
-const { create: ye, translate: fe } = Y("cascader-item"), pe = ye({
+const { create: create$1, translate } = createComponent("cascader-item");
+const _sfc_main$1 = create$1({
   components: {
-    Loading: ce,
-    Checklist: de,
-    [Q.name]: Q,
-    [R.name]: R
+    Loading,
+    Checklist,
+    [Tabs.name]: Tabs,
+    [TabPane.name]: TabPane
   },
   props: {
     visible: Boolean,
@@ -157,185 +219,269 @@ const { create: ye, translate: fe } = Y("cascader-item"), pe = ye({
     convertConfig: Object
   },
   emits: ["update:modelValue", "change", "pathChange"],
-  setup(e, { emit: l }) {
-    const a = I(() => ({
-      lazy: e.lazy,
-      lazyLoad: e.lazyLoad,
-      valueKey: e.valueKey,
-      textKey: e.textKey,
-      childrenKey: e.childrenKey,
-      convertConfig: e.convertConfig
-    })), n = N(0), r = N(!1), u = N(e.modelValue), o = N(new W([], {})), i = N([]), s = I(() => a.value.lazy && !!a.value.lazyLoad), c = /* @__PURE__ */ new Map();
-    let d;
-    const y = () => L(this, null, function* () {
-      c.clear(), i.value = [], n.value = 0, r.value = !1, d = null;
-      let { options: t } = e;
-      a.value.convertConfig && (t = ve(t, a.value.convertConfig)), o.value = new W(t, {
-        value: a.value.valueKey,
-        text: a.value.textKey,
-        children: a.value.childrenKey
-      }), s.value && !o.value.nodes.length && (yield K({
-        root: !0,
-        loading: !0,
-        text: "",
-        value: ""
-      })), i.value = [{ nodes: o.value.nodes, selectedNode: null }], h();
-    }), h = () => L(this, null, function* () {
-      const t = u.value;
-      if (t === void 0 || !o.value.nodes.length)
+  setup(props, { emit }) {
+    const configs = computed(() => ({
+      lazy: props.lazy,
+      lazyLoad: props.lazyLoad,
+      valueKey: props.valueKey,
+      textKey: props.textKey,
+      childrenKey: props.childrenKey,
+      convertConfig: props.convertConfig
+    }));
+    const tabsCursor = ref(0);
+    const initLoading = ref(false);
+    const innerValue = ref(props.modelValue);
+    const tree = ref(new Tree([], {}));
+    const panes = ref([]);
+    const isLazy = computed(() => configs.value.lazy && Boolean(configs.value.lazyLoad));
+    const lazyLoadMap = /* @__PURE__ */ new Map();
+    let currentProcessNode;
+    const init = () => __async(this, null, function* () {
+      lazyLoadMap.clear();
+      panes.value = [];
+      tabsCursor.value = 0;
+      initLoading.value = false;
+      currentProcessNode = null;
+      let { options } = props;
+      if (configs.value.convertConfig) {
+        options = convertListToOptions(options, configs.value.convertConfig);
+      }
+      tree.value = new Tree(options, {
+        value: configs.value.valueKey,
+        text: configs.value.textKey,
+        children: configs.value.childrenKey
+      });
+      if (isLazy.value && !tree.value.nodes.length) {
+        yield invokeLazyLoad({
+          root: true,
+          loading: true,
+          text: "",
+          value: ""
+        });
+      }
+      panes.value = [{ nodes: tree.value.nodes, selectedNode: null }];
+      syncValue();
+    });
+    const syncValue = () => __async(this, null, function* () {
+      const currentValue = innerValue.value;
+      if (currentValue === void 0 || !tree.value.nodes.length) {
         return;
-      if (t.length === 0) {
-        n.value = 0, i.value = [{ nodes: o.value.nodes, selectedNode: null }];
+      }
+      if (currentValue.length === 0) {
+        tabsCursor.value = 0;
+        panes.value = [{ nodes: tree.value.nodes, selectedNode: null }];
         return;
       }
-      let v = t;
-      if (s.value && Array.isArray(t) && t.length) {
-        v = [];
-        let f = o.value.nodes.find((p) => p.value === t[0]);
-        if (f) {
-          v = [f.value], r.value = !0;
-          const p = yield t.slice(1).reduce((m, C) => L(this, null, function* () {
-            var F;
-            const b = yield m;
-            yield K(b);
-            const j = (F = b == null ? void 0 : b.children) == null ? void 0 : F.find((ae) => ae.value === C);
-            return j && v.push(C), Promise.resolve(j);
-          }), Promise.resolve(f));
-          yield K(p), r.value = !1;
+      let needToSync = currentValue;
+      if (isLazy.value && Array.isArray(currentValue) && currentValue.length) {
+        needToSync = [];
+        let parent = tree.value.nodes.find((node) => node.value === currentValue[0]);
+        if (parent) {
+          needToSync = [parent.value];
+          initLoading.value = true;
+          const last = yield currentValue.slice(1).reduce((p, value) => __async(this, null, function* () {
+            var _a2;
+            const parent2 = yield p;
+            yield invokeLazyLoad(parent2);
+            const node = (_a2 = parent2 == null ? void 0 : parent2.children) == null ? void 0 : _a2.find((item) => item.value === value);
+            if (node) {
+              needToSync.push(value);
+            }
+            return Promise.resolve(node);
+          }), Promise.resolve(parent));
+          yield invokeLazyLoad(last);
+          initLoading.value = false;
         }
       }
-      v.length && t === e.modelValue && o.value.getPathNodesByValue(v).map((p, m) => {
-        n.value = m, $.handleNode(p, !0);
-      });
-    }), K = (t) => L(this, null, function* () {
-      if (!t)
+      if (needToSync.length && currentValue === props.modelValue) {
+        const pathNodes = tree.value.getPathNodesByValue(needToSync);
+        pathNodes.map((node, index2) => {
+          tabsCursor.value = index2;
+          methods.handleNode(node, true);
+        });
+      }
+    });
+    const invokeLazyLoad = (node) => __async(this, null, function* () {
+      if (!node) {
         return;
-      if (!a.value.lazyLoad) {
-        t.leaf = !0;
+      }
+      if (!configs.value.lazyLoad) {
+        node.leaf = true;
         return;
       }
-      if (o.value.isLeaf(t, s.value) || o.value.hasChildren(t, s.value))
+      if (tree.value.isLeaf(node, isLazy.value) || tree.value.hasChildren(node, isLazy.value)) {
         return;
-      t.loading = !0;
-      const v = t.root ? null : t;
-      let f = c.get(t);
-      f || (f = new Promise((m) => {
-        var C, b;
-        (b = (C = a.value).lazyLoad) == null || b.call(C, t, m);
-      }), c.set(t, f));
-      const p = yield f;
-      Array.isArray(p) && p.length > 0 ? o.value.updateChildren(p, v) : t.leaf = !0, t.loading = !1, c.delete(t);
-    }), ee = (t) => {
-      const v = t.map((f) => f.value);
-      u.value = v, l("change", v, t), l("update:modelValue", v, t);
-    }, $ = {
+      }
+      node.loading = true;
+      const parent = node.root ? null : node;
+      let lazyLoadPromise = lazyLoadMap.get(node);
+      if (!lazyLoadPromise) {
+        lazyLoadPromise = new Promise((resolve) => {
+          var _a2, _b;
+          (_b = (_a2 = configs.value).lazyLoad) == null ? void 0 : _b.call(_a2, node, resolve);
+        });
+        lazyLoadMap.set(node, lazyLoadPromise);
+      }
+      const nodes = yield lazyLoadPromise;
+      if (Array.isArray(nodes) && nodes.length > 0) {
+        tree.value.updateChildren(nodes, parent);
+      } else {
+        node.leaf = true;
+      }
+      node.loading = false;
+      lazyLoadMap.delete(node);
+    });
+    const emitChange = (pathNodes) => {
+      const emitValue = pathNodes.map((node) => node.value);
+      innerValue.value = emitValue;
+      emit("change", emitValue, pathNodes);
+      emit("update:modelValue", emitValue, pathNodes);
+    };
+    const methods = {
       // 选中一个节点，静默模式不触发事件
-      handleNode(t, v) {
-        return L(this, null, function* () {
-          const { disabled: f, loading: p } = t;
-          if (!(!v && f || !i.value[n.value])) {
-            if (o.value.isLeaf(t, s.value)) {
-              if (t.leaf = !0, i.value[n.value].selectedNode = t, i.value = i.value.slice(0, t.level + 1), !v) {
-                const m = i.value.map((C) => C.selectedNode);
-                ee(m), l("pathChange", m);
-              }
-              return;
+      handleNode(node, silent) {
+        return __async(this, null, function* () {
+          const { disabled, loading } = node;
+          if (!silent && disabled || !panes.value[tabsCursor.value]) {
+            return;
+          }
+          if (tree.value.isLeaf(node, isLazy.value)) {
+            node.leaf = true;
+            panes.value[tabsCursor.value].selectedNode = node;
+            panes.value = panes.value.slice(0, node.level + 1);
+            if (!silent) {
+              const pathNodes = panes.value.map((pane) => pane.selectedNode);
+              emitChange(pathNodes);
+              emit("pathChange", pathNodes);
             }
-            if (o.value.hasChildren(t, s.value)) {
-              const m = t.level + 1;
-              if (i.value[n.value].selectedNode = t, i.value = i.value.slice(0, m), i.value.push({
-                nodes: t.children || [],
-                selectedNode: null
-              }), n.value = m, !v) {
-                const C = i.value.map((b) => b.selectedNode);
-                l("pathChange", C);
-              }
-              return;
+            return;
+          }
+          if (tree.value.hasChildren(node, isLazy.value)) {
+            const level = node.level + 1;
+            panes.value[tabsCursor.value].selectedNode = node;
+            panes.value = panes.value.slice(0, level);
+            panes.value.push({
+              nodes: node.children || [],
+              selectedNode: null
+            });
+            tabsCursor.value = level;
+            if (!silent) {
+              const pathNodes = panes.value.map((pane) => pane.selectedNode);
+              emit("pathChange", pathNodes);
             }
-            d = t, !p && (yield K(t), d === t && (i.value[n.value].selectedNode = t, $.handleNode(t, v)));
+            return;
+          }
+          currentProcessNode = node;
+          if (loading) {
+            return;
+          }
+          yield invokeLazyLoad(node);
+          if (currentProcessNode === node) {
+            panes.value[tabsCursor.value].selectedNode = node;
+            methods.handleNode(node, silent);
           }
         });
       },
-      handleTabClick(t) {
-        d = null, n.value = Number(t.paneKey);
+      handleTabClick(tab) {
+        currentProcessNode = null;
+        tabsCursor.value = Number(tab.paneKey);
       },
-      formatTabTitle(t) {
-        return t.selectedNode ? t.selectedNode.text : fe("select");
+      formatTabTitle(pane) {
+        return pane.selectedNode ? pane.selectedNode.text : translate("select");
       },
-      isSelected(t, v) {
-        var f;
-        return ((f = t == null ? void 0 : t.selectedNode) == null ? void 0 : f.value) === v.value;
+      isSelected(pane, node) {
+        var _a2;
+        return ((_a2 = pane == null ? void 0 : pane.selectedNode) == null ? void 0 : _a2.value) === node.value;
       }
     };
-    return T(
-      [a, () => e.options],
+    watch(
+      [configs, () => props.options],
       () => {
-        y();
+        init();
       },
       {
-        deep: !0,
-        immediate: !0
+        deep: true,
+        immediate: true
       }
-    ), T(
-      () => e.modelValue,
-      (t) => {
-        t !== u.value && (u.value = t, h());
+    );
+    watch(
+      () => props.modelValue,
+      (value) => {
+        if (value !== innerValue.value) {
+          innerValue.value = value;
+          syncValue();
+        }
       }
-    ), T(
-      () => e.visible,
-      (t) => {
-        t && Array.isArray(u.value) && u.value.length > 0 && h();
+    );
+    watch(
+      () => props.visible,
+      (val) => {
+        if (val && Array.isArray(innerValue.value) && innerValue.value.length > 0) {
+          syncValue();
+        }
       }
-    ), k({ panes: i, initLoading: r, tabsCursor: n }, $);
+    );
+    return __spreadValues({ panes, initLoading, tabsCursor }, methods);
   }
-}), me = {
+});
+const _hoisted_1$1 = {
   role: "menu",
   class: "nut-cascader-pane"
-}, ge = ["aria-checked", "aria-disabled", "onClick"], Ce = { class: "nut-cascader-item__title" }, be = /* @__PURE__ */ M("view", { class: "nut-cascader-pane" }, null, -1);
-function ke(e, l, a, n, r, u) {
-  const o = z("Loading"), i = z("Checklist"), s = z("nut-tab-pane"), c = z("nut-tabs");
-  return g(), V(c, {
+};
+const _hoisted_2 = ["aria-checked", "aria-disabled", "onClick"];
+const _hoisted_3 = { class: "nut-cascader-item__title" };
+const _hoisted_4 = /* @__PURE__ */ createElementVNode("view", { class: "nut-cascader-pane" }, null, -1);
+function _sfc_render$1(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_Loading = resolveComponent("Loading");
+  const _component_Checklist = resolveComponent("Checklist");
+  const _component_nut_tab_pane = resolveComponent("nut-tab-pane");
+  const _component_nut_tabs = resolveComponent("nut-tabs");
+  return openBlock(), createBlock(_component_nut_tabs, {
     class: "nut-cascader",
-    modelValue: e.tabsCursor,
-    "onUpdate:modelValue": l[0] || (l[0] = (d) => e.tabsCursor = d),
-    onClick: e.handleTabClick,
+    modelValue: _ctx.tabsCursor,
+    "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => _ctx.tabsCursor = $event),
+    onClick: _ctx.handleTabClick,
     "title-scroll": ""
   }, {
-    default: _(() => [
-      !e.initLoading && e.panes.length ? (g(!0), A(q, { key: 0 }, G(e.panes, (d, y) => (g(), V(s, {
-        title: e.formatTabTitle(d),
-        key: y
-      }, {
-        default: _(() => [
-          M("view", me, [
-            (g(!0), A(q, null, G(d.nodes, (h) => (g(), A("view", {
-              key: h.value,
-              class: oe(["nut-cascader-item", { active: e.isSelected(d, h), disabled: h.disabled }]),
-              "aria-checked": e.isSelected(d, h),
-              "aria-disabled": h.disabled || void 0,
-              role: "menuitemradio",
-              onClick: (K) => e.handleNode(h, !1)
-            }, [
-              M("view", Ce, ie(h.text), 1),
-              h.loading ? (g(), V(o, {
-                key: 0,
-                class: "nut-cascader-item__icon-loading",
-                name: "loading"
-              })) : (g(), V(i, {
-                key: 1,
-                class: "nut-cascader-item__icon-check",
-                name: "checklist"
-              }))
-            ], 10, ge))), 128))
-          ])
-        ]),
-        _: 2
-      }, 1032, ["title"]))), 128)) : (g(), V(s, {
+    default: withCtx(() => [
+      !_ctx.initLoading && _ctx.panes.length ? (openBlock(true), createElementBlock(Fragment, { key: 0 }, renderList(_ctx.panes, (pane, index2) => {
+        return openBlock(), createBlock(_component_nut_tab_pane, {
+          title: _ctx.formatTabTitle(pane),
+          key: index2
+        }, {
+          default: withCtx(() => [
+            createElementVNode("view", _hoisted_1$1, [
+              (openBlock(true), createElementBlock(Fragment, null, renderList(pane.nodes, (node) => {
+                return openBlock(), createElementBlock("view", {
+                  key: node.value,
+                  class: normalizeClass(["nut-cascader-item", { active: _ctx.isSelected(pane, node), disabled: node.disabled }]),
+                  "aria-checked": _ctx.isSelected(pane, node),
+                  "aria-disabled": node.disabled || void 0,
+                  role: "menuitemradio",
+                  onClick: ($event) => _ctx.handleNode(node, false)
+                }, [
+                  createElementVNode("view", _hoisted_3, toDisplayString(node.text), 1),
+                  node.loading ? (openBlock(), createBlock(_component_Loading, {
+                    key: 0,
+                    class: "nut-cascader-item__icon-loading",
+                    name: "loading"
+                  })) : (openBlock(), createBlock(_component_Checklist, {
+                    key: 1,
+                    class: "nut-cascader-item__icon-check",
+                    name: "checklist"
+                  }))
+                ], 10, _hoisted_2);
+              }), 128))
+            ])
+          ]),
+          _: 2
+        }, 1032, ["title"]);
+      }), 128)) : (openBlock(), createBlock(_component_nut_tab_pane, {
         key: 1,
         title: "Loading..."
       }, {
-        default: _(() => [
-          be
+        default: withCtx(() => [
+          _hoisted_4
         ]),
         _: 1
       }))
@@ -343,12 +489,14 @@ function ke(e, l, a, n, r, u) {
     _: 1
   }, 8, ["modelValue", "onClick"]);
 }
-const X = /* @__PURE__ */ Z(pe, [["render", ke]]), { create: Ve } = Y("cascader"), Le = Ve({
+const CascaderItem = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["render", _sfc_render$1]]);
+const { create } = createComponent("cascader");
+const _sfc_main = create({
   components: {
-    [X.name]: X,
-    [J.name]: J
+    [CascaderItem.name]: CascaderItem,
+    [Popup.name]: Popup
   },
-  props: O(k({}, ue), {
+  props: __spreadProps(__spreadValues({}, popupProps), {
     modelValue: Array,
     visible: Boolean,
     title: String,
@@ -372,87 +520,98 @@ const X = /* @__PURE__ */ Z(pe, [["render", ke]]), { create: Ve } = Y("cascader"
     },
     poppable: {
       type: Boolean,
-      default: !0
+      default: true
     },
     convertConfig: Object
   }),
   emits: ["update:modelValue", "change", "pathChange", "update:visible"],
-  setup(e, { emit: l }) {
-    const a = N(e.modelValue), n = I({
+  setup(props, { emit }) {
+    const innerValue = ref(props.modelValue);
+    const innerVisible = computed({
       get() {
-        return e.visible;
+        return props.visible;
       },
-      set(o) {
-        l("update:visible", o);
+      set(value) {
+        emit("update:visible", value);
       }
-    }), r = (o, i) => {
-      a.value = o, n.value = !1, l("change", o, i), l("update:modelValue", o);
-    }, u = (o) => {
-      l("pathChange", o);
+    });
+    const onChange = (value, pathNodes) => {
+      innerValue.value = value;
+      innerVisible.value = false;
+      emit("change", value, pathNodes);
+      emit("update:modelValue", value);
     };
-    return T(
-      () => e.modelValue,
-      (o) => {
-        o !== a.value && (a.value = o);
+    const onPathChange = (pathNodes) => {
+      emit("pathChange", pathNodes);
+    };
+    watch(
+      () => props.modelValue,
+      (value) => {
+        if (value !== innerValue.value) {
+          innerValue.value = value;
+        }
       }
-    ), {
-      onChange: r,
-      onPathChange: u,
-      innerValue: a,
-      innerVisible: n
+    );
+    return {
+      onChange,
+      onPathChange,
+      innerValue,
+      innerVisible
     };
   }
-}), Ne = ["innerHTML"];
-function ze(e, l, a, n, r, u) {
-  const o = z("nut-cascader-item"), i = z("nut-popup");
-  return e.poppable ? (g(), V(i, {
+});
+const _hoisted_1 = ["innerHTML"];
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_nut_cascader_item = resolveComponent("nut-cascader-item");
+  const _component_nut_popup = resolveComponent("nut-popup");
+  return _ctx.poppable ? (openBlock(), createBlock(_component_nut_popup, {
     key: 0,
-    visible: e.innerVisible,
-    "onUpdate:visible": l[0] || (l[0] = (s) => e.innerVisible = s),
+    visible: _ctx.innerVisible,
+    "onUpdate:visible": _cache[0] || (_cache[0] = ($event) => _ctx.innerVisible = $event),
     position: "bottom",
     "pop-class": "nut-cascader__popup",
     round: "",
-    closeable: e.closeable,
-    "destroy-on-close": !1,
-    "close-icon-position": e.closeIconPosition
+    closeable: _ctx.closeable,
+    "destroy-on-close": false,
+    "close-icon-position": _ctx.closeIconPosition
   }, {
-    default: _(() => [
-      e.title ? (g(), A("view", {
+    default: withCtx(() => [
+      _ctx.title ? (openBlock(), createElementBlock("view", {
         key: 0,
         class: "nut-cascader__bar",
-        innerHTML: e.title
-      }, null, 8, Ne)) : se("", !0),
-      re(o, {
-        onChange: e.onChange,
-        onPathChange: e.onPathChange,
-        modelValue: e.innerValue,
-        options: e.options,
-        lazy: e.lazy,
-        "lazy-load": e.lazyLoad,
-        "value-key": e.valueKey,
-        "text-key": e.textKey,
-        "children-key": e.childrenKey,
-        "convert-config": e.convertConfig,
-        visible: e.innerVisible
+        innerHTML: _ctx.title
+      }, null, 8, _hoisted_1)) : createCommentVNode("", true),
+      createVNode(_component_nut_cascader_item, {
+        onChange: _ctx.onChange,
+        onPathChange: _ctx.onPathChange,
+        modelValue: _ctx.innerValue,
+        options: _ctx.options,
+        lazy: _ctx.lazy,
+        "lazy-load": _ctx.lazyLoad,
+        "value-key": _ctx.valueKey,
+        "text-key": _ctx.textKey,
+        "children-key": _ctx.childrenKey,
+        "convert-config": _ctx.convertConfig,
+        visible: _ctx.innerVisible
       }, null, 8, ["onChange", "onPathChange", "modelValue", "options", "lazy", "lazy-load", "value-key", "text-key", "children-key", "convert-config", "visible"])
     ]),
     _: 1
-  }, 8, ["visible", "closeable", "close-icon-position"])) : (g(), V(o, {
+  }, 8, ["visible", "closeable", "close-icon-position"])) : (openBlock(), createBlock(_component_nut_cascader_item, {
     key: 1,
-    onChange: e.onChange,
-    onPathChange: e.onPathChange,
-    modelValue: e.innerValue,
-    options: e.options,
-    lazy: e.lazy,
-    "lazy-load": e.lazyLoad,
-    "value-key": e.valueKey,
-    "text-key": e.textKey,
-    "children-key": e.childrenKey,
-    "convert-config": e.convertConfig,
-    visible: e.innerVisible
+    onChange: _ctx.onChange,
+    onPathChange: _ctx.onPathChange,
+    modelValue: _ctx.innerValue,
+    options: _ctx.options,
+    lazy: _ctx.lazy,
+    "lazy-load": _ctx.lazyLoad,
+    "value-key": _ctx.valueKey,
+    "text-key": _ctx.textKey,
+    "children-key": _ctx.childrenKey,
+    "convert-config": _ctx.convertConfig,
+    visible: _ctx.innerVisible
   }, null, 8, ["onChange", "onPathChange", "modelValue", "options", "lazy", "lazy-load", "value-key", "text-key", "children-key", "convert-config", "visible"]));
 }
-const He = /* @__PURE__ */ Z(Le, [["render", ze]]);
+const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
 export {
-  He as default
+  index as default
 };