@nutui/nutui 3.1.22-beta.0 → 3.1.22-beta.3

package/dist/packages/_es/Cascader.js

@@ -5,18 +5,18 @@ 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]);
+var __spreadValues = (a2, b2) => {
+  for (var prop in b2 || (b2 = {}))
+    if (__hasOwnProp.call(b2, prop))
+      __defNormalProp(a2, prop, b2[prop]);
   if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
+    for (var prop of __getOwnPropSymbols(b2)) {
+      if (__propIsEnum.call(b2, prop))
+        __defNormalProp(a2, prop, b2[prop]);
     }
-  return a;
+  return a2;
 };
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __spreadProps = (a2, b2) => __defProps(a2, __getOwnPropDescs(b2));
 var __restKey = (key) => typeof key === "symbol" ? key : key + "";
 var __objRest = (source, exclude) => {
   var target = {};
@@ -31,516 +31,172 @@ var __objRest = (source, exclude) => {
   return target;
 };
 /*!
-* @nutui/nutui v3.1.22-beta.0 Tue May 31 2022 21:47:10 GMT+0800 (中国标准时间)
+* @nutui/nutui v3.1.22-beta.3 Wed Jun 15 2022 20:12:30 GMT+0800 (中国标准时间)
 * (c) 2022 @jdf2e.
 * Released under the MIT License.
 */
-import { computed, ref, watch, resolveComponent, openBlock, createBlock, withCtx, createElementBlock, Fragment, renderList, createElementVNode, normalizeClass, toDisplayString, createCommentVNode, createVNode } from "vue";
-import { popupProps } from "./Popup.js";
-import { c as createComponent } from "./component.js";
-import { _ as _export_sfc } from "./plugin-vue_export-helper.js";
+import { computed as e, ref as l, watch as a, resolveComponent as t, openBlock as n, createBlock as o, withCtx as i, createElementBlock as s, Fragment as r, renderList as u, createElementVNode as d, normalizeClass as c, toDisplayString as v, createCommentVNode as h, createVNode as p } from "vue";
+import { popupProps as y } from "./Popup.js";
+import { c as g } from "./component.js";
+import { _ as f } from "./plugin-vue_export-helper.js";
 import "./OverLay.js";
 import "../locale/lang";
 import "./Icon.js";
 import "./pxCheck.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
-  });
-  if (newNode.children && newNode.children.length) {
-    newNode.children = formatTree(newNode.children, newNode, config);
+const m = (e2, l2, a2) => e2.map((e3) => {
+  const { value: t2 = "value", text: n2 = "text", children: o2 = "children" } = a2, _a = e3, { [t2]: i2, [n2]: s2, [o2]: r2 } = _a, u2 = __objRest(_a, [__restKey(t2), __restKey(n2), __restKey(o2)]), d2 = __spreadProps(__spreadValues({ loading: false }, u2), { level: l2 ? (l2 && l2.level || 0) + 1 : 0, value: i2, text: s2, children: r2, _parent: l2 });
+  return d2.children && d2.children.length && (d2.children = m(d2.children, d2, a2)), d2;
+}), b = (e2, l2) => {
+  let a2, t2 = 0;
+  for (; (a2 = e2[t2++]) && l2(a2) !== true; )
+    a2.children && a2.children.length && b(a2.children, l2);
+}, C = { topId: null, idKey: "id", pidKey: "pid", sortKey: "" };
+class k {
+  constructor(e2, l2) {
+    this.config = __spreadValues({ value: "value", text: "text", children: "children" }, l2 || {}), this.nodes = m(e2, null, this.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);
-    }
+  updateChildren(e2, l2) {
+    l2 ? l2.children = m(e2, l2, this.config) : this.nodes = m(e2, null, this.config);
   }
-};
-const defaultConvertConfig = {
-  topId: null,
-  idKey: "id",
-  pidKey: "pid",
-  sortKey: ""
-};
-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]);
-      }
-    });
+  getNodeByValue(e2) {
+    let l2;
+    return b(this.nodes, (a2) => {
+      if (a2.value === e2)
+        return l2 = a2, true;
+    }), l2;
   }
-  map = null;
-  return result;
-};
-class Tree {
-  constructor(nodes, config) {
-    this.config = __spreadValues({
-      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);
-    }
-  }
-  getNodeByValue(value) {
-    let foundNode;
-    eachTree(this.nodes, (node) => {
-      if (node.value === value) {
-        foundNode = node;
-        return true;
-      }
-    });
-    return foundNode;
-  }
-  getPathNodesByValue(value) {
-    if (!value.length) {
+  getPathNodesByValue(e2) {
+    if (!e2.length)
       return [];
-    }
-    const pathNodes = [];
-    let currentNodes = this.nodes;
-    while (currentNodes && currentNodes.length) {
-      const foundNode = currentNodes.find((node) => node.value === value[node.level]);
-      if (!foundNode) {
+    const l2 = [];
+    let a2 = this.nodes;
+    for (; a2 && a2.length; ) {
+      const t2 = a2.find((l3) => l3.value === e2[l3.level]);
+      if (!t2)
         break;
-      }
-      pathNodes.push(foundNode);
-      currentNodes = foundNode.children;
+      l2.push(t2), a2 = t2.children;
     }
-    return pathNodes;
+    return l2;
   }
-  isLeaf(node, lazy) {
-    const { leaf, children } = node;
-    const hasChildren = Array.isArray(children) && Boolean(children.length);
-    return leaf || !hasChildren && !lazy;
+  isLeaf(e2, l2) {
+    const { leaf: a2, children: t2 } = e2, n2 = Array.isArray(t2) && Boolean(t2.length);
+    return a2 || !n2 && !l2;
   }
-  hasChildren(node, lazy) {
-    const isLeaf = this.isLeaf(node, lazy);
-    if (isLeaf) {
+  hasChildren(e2, l2) {
+    if (this.isLeaf(e2, l2))
       return false;
-    }
-    const { children } = node;
-    return Array.isArray(children) && Boolean(children.length);
+    const { children: a2 } = e2;
+    return Array.isArray(a2) && Boolean(a2.length);
   }
 }
-const { create: create$1, translate } = createComponent("cascader-item");
-const _sfc_main$1 = create$1({
-  props: {
-    visible: Boolean,
-    modelValue: Array,
-    options: {
-      type: Array,
-      default: () => []
-    },
-    lazy: Boolean,
-    lazyLoad: Function,
-    valueKey: {
-      type: String,
-      default: "value"
-    },
-    textKey: {
-      type: String,
-      default: "text"
-    },
-    childrenKey: {
-      type: String,
-      default: "children"
-    },
-    convertConfig: Object
-  },
-  components: {},
-  emits: ["update:modelValue", "change", "pathChange"],
-  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 () => {
-      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);
+const { create: K, translate: V } = g("cascader-item"), x = K({ props: { visible: Boolean, modelValue: Array, options: { type: Array, default: () => [] }, lazy: Boolean, lazyLoad: Function, valueKey: { type: String, default: "value" }, textKey: { type: String, default: "text" }, childrenKey: { type: String, default: "children" }, convertConfig: Object }, components: {}, emits: ["update:modelValue", "change", "pathChange"], setup(t2, { emit: n2 }) {
+  const o2 = e(() => ({ lazy: t2.lazy, lazyLoad: t2.lazyLoad, valueKey: t2.valueKey, textKey: t2.textKey, childrenKey: t2.childrenKey, convertConfig: t2.convertConfig })), i2 = l(0), s2 = l(false), r2 = l(t2.modelValue), u2 = l(new k([], {})), d2 = l([]), c2 = e(() => o2.value.lazy && Boolean(o2.value.lazyLoad)), v2 = /* @__PURE__ */ new Map();
+  let h2;
+  const p2 = async () => {
+    v2.clear(), d2.value = [], i2.value = 0, s2.value = false, h2 = null;
+    let { options: e2 } = t2;
+    o2.value.convertConfig && (e2 = ((e3, l2) => {
+      const a2 = __spreadValues(__spreadValues({}, C), l2 || {}), { topId: t3, idKey: n3, pidKey: o3, sortKey: i3 } = a2;
+      let s3 = [], r3 = {};
+      return e3.forEach((e4) => {
+        e4 = __spreadValues({}, e4);
+        const { [n3]: l3, [o3]: a3 } = e4, i4 = r3[a3] = r3[a3] || [];
+        s3.length || a3 !== t3 || (s3 = i4), i4.push(e4), e4.children = r3[l3] || (r3[l3] = []);
+      }), i3 && Object.keys(r3).forEach((e4) => {
+        r3[e4].length > 1 && r3[e4].sort((e5, l3) => e5[i3] - l3[i3]);
+      }), r3 = null, s3;
+    })(e2, o2.value.convertConfig)), u2.value = new k(e2, { value: o2.value.valueKey, text: o2.value.textKey, children: o2.value.childrenKey }), c2.value && !u2.value.nodes.length && await g2({ root: true, loading: true, text: "", value: "" }), d2.value = [{ nodes: u2.value.nodes, selectedNode: null }], y2();
+  }, y2 = async () => {
+    const e2 = r2.value;
+    if (e2 === void 0 || !u2.value.nodes.length)
+      return;
+    if (e2.length === 0)
+      return i2.value = 0, void (d2.value = [{ nodes: u2.value.nodes, selectedNode: null }]);
+    let l2 = e2;
+    if (c2.value && Array.isArray(e2) && e2.length) {
+      l2 = [];
+      let a2 = u2.value.nodes.find((l3) => l3.value === e2[0]);
+      if (a2) {
+        l2 = [a2.value], s2.value = true;
+        const t3 = await e2.slice(1).reduce(async (e3, a3) => {
+          var _a;
+          const t4 = await e3;
+          await g2(t4);
+          const n3 = (_a = t4 == null ? void 0 : t4.children) == null ? void 0 : _a.find((e4) => e4.value === a3);
+          return n3 && l2.push(a3), Promise.resolve(n3);
+        }, Promise.resolve(a2));
+        await g2(t3), s2.value = false;
       }
-      tree.value = new Tree(options, {
-        value: configs.value.valueKey,
-        text: configs.value.textKey,
-        children: configs.value.childrenKey
+    }
+    if (l2.length && e2 === t2.modelValue) {
+      u2.value.getPathNodesByValue(l2).map((e3, l3) => {
+        i2.value = l3, f2.handleNode(e3, true);
       });
-      if (isLazy.value && !tree.value.nodes.length) {
-        await invokeLazyLoad({
-          root: true,
-          loading: true,
-          text: "",
-          value: ""
-        });
-      }
-      panes.value = [{ nodes: tree.value.nodes, selectedNode: null }];
-      syncValue();
-    };
-    const syncValue = async () => {
-      const currentValue = innerValue.value;
-      if (currentValue === void 0 || !tree.value.nodes.length) {
-        return;
-      }
-      if (currentValue.length === 0) {
-        tabsCursor.value = 0;
-        panes.value = [{ nodes: tree.value.nodes, selectedNode: null }];
-        return;
-      }
-      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 = await currentValue.slice(1).reduce(async (p, value) => {
-            var _a;
-            const parent2 = await p;
-            await invokeLazyLoad(parent2);
-            const node = (_a = parent2 == null ? void 0 : parent2.children) == null ? void 0 : _a.find((item) => item.value === value);
-            if (node) {
-              needToSync.push(value);
-            }
-            return Promise.resolve(node);
-          }, Promise.resolve(parent));
-          await invokeLazyLoad(last);
-          initLoading.value = false;
-        }
-      }
-      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 = async (node) => {
-      if (!node) {
-        return;
-      }
-      if (!configs.value.lazyLoad) {
-        node.leaf = true;
-        return;
-      }
-      if (tree.value.isLeaf(node, isLazy.value) || tree.value.hasChildren(node, isLazy.value)) {
-        return;
-      }
-      node.loading = true;
-      const parent = node.root ? null : node;
-      let lazyLoadPromise = lazyLoadMap.get(node);
-      if (!lazyLoadPromise) {
-        lazyLoadPromise = new Promise((resolve) => {
-          var _a, _b;
-          (_b = (_a = configs.value).lazyLoad) == null ? void 0 : _b.call(_a, node, resolve);
-        });
-        lazyLoadMap.set(node, lazyLoadPromise);
-      }
-      const nodes = await 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 = {
-      async handleNode(node, silent) {
-        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);
-          }
-          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);
-          }
-          return;
-        }
-        currentProcessNode = node;
-        if (loading) {
-          return;
+    }
+  }, g2 = async (e2) => {
+    if (!e2)
+      return;
+    if (!o2.value.lazyLoad)
+      return void (e2.leaf = true);
+    if (u2.value.isLeaf(e2, c2.value) || u2.value.hasChildren(e2, c2.value))
+      return;
+    e2.loading = true;
+    const l2 = e2.root ? null : e2;
+    let a2 = v2.get(e2);
+    a2 || (a2 = new Promise((l3) => {
+      var _a, _b;
+      (_b = (_a = o2.value).lazyLoad) == null ? void 0 : _b.call(_a, e2, l3);
+    }), v2.set(e2, a2));
+    const t3 = await a2;
+    Array.isArray(t3) && t3.length > 0 ? u2.value.updateChildren(t3, l2) : e2.leaf = true, e2.loading = false, v2.delete(e2);
+  }, f2 = { async handleNode(e2, l2) {
+    const { disabled: a2, loading: t3 } = e2;
+    if ((l2 || !a2) && d2.value[i2.value])
+      if (u2.value.isLeaf(e2, c2.value)) {
+        if (e2.leaf = true, d2.value[i2.value].selectedNode = e2, d2.value = d2.value.slice(0, e2.level + 1), !l2) {
+          const e3 = d2.value.map((e4) => e4.selectedNode);
+          ((e4) => {
+            const l3 = e4.map((e5) => e5.value);
+            r2.value = l3, n2("change", l3, e4), n2("update:modelValue", l3, e4);
+          })(e3), n2("pathChange", e3);
         }
-        await invokeLazyLoad(node);
-        if (currentProcessNode === node) {
-          panes.value[tabsCursor.value].selectedNode = node;
-          methods.handleNode(node, silent);
+      } else if (u2.value.hasChildren(e2, c2.value)) {
+        const a3 = e2.level + 1;
+        if (d2.value[i2.value].selectedNode = e2, d2.value = d2.value.slice(0, a3), d2.value.push({ nodes: e2.children || [], selectedNode: null }), i2.value = a3, !l2) {
+          const e3 = d2.value.map((e4) => e4.selectedNode);
+          n2("pathChange", e3);
         }
-      },
-      handleTabClick(tab) {
-        currentProcessNode = null;
-        tabsCursor.value = tab.paneKey;
-      },
-      formatTabTitle(pane) {
-        return pane.selectedNode ? pane.selectedNode.text : translate("select");
-      },
-      isSelected(pane, node) {
-        return pane.selectedNode && pane.selectedNode.value === node.value;
-      }
-    };
-    watch([configs, () => props.options], () => {
-      init();
-    }, {
-      deep: true,
-      immediate: true
-    });
-    watch(() => props.modelValue, (value) => {
-      if (value !== innerValue.value) {
-        innerValue.value = value;
-        syncValue();
-      }
-    });
-    watch(() => props.visible, (val) => {
-      if (val && Array.isArray(innerValue.value) && innerValue.value.length > 0) {
-        syncValue();
-      }
-    });
-    return __spreadValues({ panes, initLoading, tabsCursor }, methods);
-  }
-});
-const _hoisted_1$1 = {
-  role: "menu",
-  class: "nut-cascader-pane"
-};
-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_nut_icon = resolveComponent("nut-icon");
-  const _component_nut_tabpane = resolveComponent("nut-tabpane");
-  const _component_nut_tabs = resolveComponent("nut-tabs");
-  return openBlock(), createBlock(_component_nut_tabs, {
-    class: "nut-cascader",
-    modelValue: _ctx.tabsCursor,
-    "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => _ctx.tabsCursor = $event),
-    onClick: _ctx.handleTabClick,
-    "title-scroll": ""
-  }, {
-    default: withCtx(() => [
-      !_ctx.initLoading && _ctx.panes.length ? (openBlock(true), createElementBlock(Fragment, { key: 0 }, renderList(_ctx.panes, (pane, index2) => {
-        return openBlock(), createBlock(_component_nut_tabpane, {
-          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_nut_icon, {
-                    key: 0,
-                    class: "nut-cascader-item__icon-loading",
-                    name: "loading"
-                  })) : (openBlock(), createBlock(_component_nut_icon, {
-                    key: 1,
-                    class: "nut-cascader-item__icon-check",
-                    name: "checklist"
-                  }))
-                ], 10, _hoisted_2);
-              }), 128))
-            ])
-          ]),
-          _: 2
-        }, 1032, ["title"]);
-      }), 128)) : (openBlock(), createBlock(_component_nut_tabpane, {
-        key: 1,
-        title: "Loading..."
-      }, {
-        default: withCtx(() => [
-          _hoisted_4
-        ]),
-        _: 1
-      }))
-    ]),
-    _: 1
-  }, 8, ["modelValue", "onClick"]);
-}
-var CascaderItem = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["render", _sfc_render$1]]);
-const { create } = createComponent("cascader");
-const _sfc_main = create({
-  components: {
-    [CascaderItem.name]: CascaderItem
-  },
-  props: __spreadProps(__spreadValues({}, popupProps), {
-    modelValue: Array,
-    visible: Boolean,
-    title: String,
-    options: {
-      type: Array,
-      default: () => []
-    },
-    lazy: Boolean,
-    lazyLoad: Function,
-    valueKey: {
-      type: String,
-      default: "value"
-    },
-    textKey: {
-      type: String,
-      default: "text"
-    },
-    childrenKey: {
-      type: String,
-      default: "children"
-    },
-    convertConfig: Object
-  }),
-  emits: ["update:modelValue", "change", "pathChange", "update:visible"],
-  setup(props, { emit }) {
-    const innerValue = ref(props.modelValue);
-    const innerVisible = computed({
-      get() {
-        return props.visible;
-      },
-      set(value) {
-        emit("update:visible", value);
-      }
-    });
-    const onChange = (value, pathNodes) => {
-      innerValue.value = value;
-      innerVisible.value = false;
-      emit("change", value, pathNodes);
-      emit("update:modelValue", value);
-    };
-    const onPathChange = (pathNodes) => {
-      emit("pathChange", pathNodes);
-    };
-    watch(() => props.modelValue, (value) => {
-      if (value !== innerValue.value) {
-        innerValue.value = value;
-      }
-    });
-    return {
-      onChange,
-      onPathChange,
-      innerValue,
-      innerVisible
-    };
-  }
-});
-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 openBlock(), createBlock(_component_nut_popup, {
-    visible: _ctx.innerVisible,
-    "onUpdate:visible": _cache[0] || (_cache[0] = ($event) => _ctx.innerVisible = $event),
-    position: "bottom",
-    "pop-class": "nut-cascader__popup",
-    round: "",
-    closeable: !_ctx.closeable,
-    "close-icon": _ctx.closeIcon,
-    "destroy-on-close": false,
-    "close-icon-position": _ctx.closeIconPosition
-  }, {
-    default: withCtx(() => [
-      _ctx.title ? (openBlock(), createElementBlock("view", {
-        key: 0,
-        class: "nut-cascader__bar",
-        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", "close-icon-position"]);
-}
-var index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
-export { index as default };
+      } else
+        h2 = e2, t3 || (await g2(e2), h2 === e2 && (d2.value[i2.value].selectedNode = e2, f2.handleNode(e2, l2)));
+  }, handleTabClick(e2) {
+    h2 = null, i2.value = e2.paneKey;
+  }, formatTabTitle: (e2) => e2.selectedNode ? e2.selectedNode.text : V("select"), isSelected: (e2, l2) => e2.selectedNode && e2.selectedNode.value === l2.value };
+  return a([o2, () => t2.options], () => {
+    p2();
+  }, { deep: true, immediate: true }), a(() => t2.modelValue, (e2) => {
+    e2 !== r2.value && (r2.value = e2, y2());
+  }), a(() => t2.visible, (e2) => {
+    e2 && Array.isArray(r2.value) && r2.value.length > 0 && y2();
+  }), __spreadValues({ panes: d2, initLoading: s2, tabsCursor: i2 }, f2);
+} }), N = { role: "menu", class: "nut-cascader-pane" }, z = ["aria-checked", "aria-disabled", "onClick"], L = { class: "nut-cascader-item__title" }, _ = d("view", { class: "nut-cascader-pane" }, null, -1);
+var w = f(x, [["render", function(e2, l2, a2, h2, p2, y2) {
+  const g2 = t("nut-icon"), f2 = t("nut-tabpane"), m2 = t("nut-tabs");
+  return n(), o(m2, { class: "nut-cascader", modelValue: e2.tabsCursor, "onUpdate:modelValue": l2[0] || (l2[0] = (l3) => e2.tabsCursor = l3), onClick: e2.handleTabClick, "title-scroll": "" }, { default: i(() => [!e2.initLoading && e2.panes.length ? (n(true), s(r, { key: 0 }, u(e2.panes, (l3, a3) => (n(), o(f2, { title: e2.formatTabTitle(l3), key: a3 }, { default: i(() => [d("view", N, [(n(true), s(r, null, u(l3.nodes, (a4) => (n(), s("view", { key: a4.value, class: c(["nut-cascader-item", { active: e2.isSelected(l3, a4), disabled: a4.disabled }]), "aria-checked": e2.isSelected(l3, a4), "aria-disabled": a4.disabled || void 0, role: "menuitemradio", onClick: (l4) => e2.handleNode(a4, false) }, [d("view", L, v(a4.text), 1), a4.loading ? (n(), o(g2, { key: 0, class: "nut-cascader-item__icon-loading", name: "loading" })) : (n(), o(g2, { key: 1, class: "nut-cascader-item__icon-check", name: "checklist" }))], 10, z))), 128))])]), _: 2 }, 1032, ["title"]))), 128)) : (n(), o(f2, { key: 1, title: "Loading..." }, { default: i(() => [_]), _: 1 }))]), _: 1 }, 8, ["modelValue", "onClick"]);
+}]]);
+const { create: A } = g("cascader"), P = A({ components: { [w.name]: w }, props: __spreadProps(__spreadValues({}, y), { modelValue: Array, visible: Boolean, title: String, options: { type: Array, default: () => [] }, lazy: Boolean, lazyLoad: Function, valueKey: { type: String, default: "value" }, textKey: { type: String, default: "text" }, childrenKey: { type: String, default: "children" }, convertConfig: Object }), emits: ["update:modelValue", "change", "pathChange", "update:visible"], setup(t2, { emit: n2 }) {
+  const o2 = l(t2.modelValue), i2 = e({ get: () => t2.visible, set(e2) {
+    n2("update:visible", e2);
+  } });
+  return a(() => t2.modelValue, (e2) => {
+    e2 !== o2.value && (o2.value = e2);
+  }), { onChange: (e2, l2) => {
+    o2.value = e2, i2.value = false, n2("change", e2, l2), n2("update:modelValue", e2);
+  }, onPathChange: (e2) => {
+    n2("pathChange", e2);
+  }, innerValue: o2, innerVisible: i2 };
+} }), B = ["innerHTML"];
+var S = f(P, [["render", function(e2, l2, a2, r2, u2, d2) {
+  const c2 = t("nut-cascader-item"), v2 = t("nut-popup");
+  return n(), o(v2, { visible: e2.innerVisible, "onUpdate:visible": l2[0] || (l2[0] = (l3) => e2.innerVisible = l3), position: "bottom", "pop-class": "nut-cascader__popup", round: "", closeable: !e2.closeable, "close-icon": e2.closeIcon, "destroy-on-close": false, "close-icon-position": e2.closeIconPosition }, { default: i(() => [e2.title ? (n(), s("view", { key: 0, class: "nut-cascader__bar", innerHTML: e2.title }, null, 8, B)) : h("", true), p(c2, { onChange: e2.onChange, onPathChange: e2.onPathChange, modelValue: e2.innerValue, options: e2.options, lazy: e2.lazy, "lazy-load": e2.lazyLoad, "value-key": e2.valueKey, "text-key": e2.textKey, "children-key": e2.childrenKey, "convert-config": e2.convertConfig, visible: e2.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", "close-icon-position"]);
+}]]);
+export { S as default };