@yqg/permission 1.2.1 → 1.3.0-alpha.1

package/dist/category-selector-BQ0-kg3o.js

@@ -0,0 +1,1275 @@
+import { a as ht, p as pt, d as Ve, r as fe, c as y, w as be, q as mt, s as M, E as ae, e as U, b as Ge, y as oe, $ as gt, G as yt, K as ue, L as Ze, M as Me, N as Be, R as ye, u as W, P as we, F as bt, Y as Ct, f as St, U as et, z as wt } from "./index-wLkVeDMW.js";
+import { a as X, _ as b, W as xt, X as Vt, ae as it, aX as tt, Y as Ie, P as ve, N as It, R as ut, V as kt, aN as $e, $ as Nt, ar as Tt, as as Lt, aY as Et, c as at, b as _t, ak as je, aj as Pt, a0 as Dt, ai as At, am as We, aU as Kt, aP as xe, aQ as Ft } from "./yqg-permission-BjVCs5lN.js";
+import { u as Ot, a as Ht, b as Rt, c as Mt, d as Bt, t as lt, B as $t, e as jt, f as Wt, g as Ut } from "./index-D_0ZQip-.js";
+import { K as de, T as zt, c as Xt, a as Xe, u as Yt, g as qt, b as Gt, d as Qt, F as Jt, e as Zt, f as ea, r as ta, h as aa, i as la } from "./apply-modal-CpmDDWWV.js";
+function na(e) {
+  return Array.isArray(e) ? e : e !== void 0 ? [e] : [];
+}
+function oa(e) {
+  const {
+    label: s,
+    value: l,
+    children: t
+  } = e || {}, a = l || "value";
+  return {
+    _title: s ? [s] : ["title", "label"],
+    value: a,
+    key: a,
+    children: t || "children"
+  };
+}
+function Ye(e) {
+  return e.disabled || e.disableCheckbox || e.checkable === !1;
+}
+function ra(e, s) {
+  const l = [];
+  function t(a) {
+    a.forEach((n) => {
+      l.push(n[s.value]);
+      const o = n[s.children];
+      o && t(o);
+    });
+  }
+  return t(e), l;
+}
+function nt(e) {
+  return e == null;
+}
+const dt = Symbol("TreeSelectContextPropsKey");
+function sa(e) {
+  return pt(dt, e);
+}
+function ca() {
+  return ht(dt, {});
+}
+const ia = {
+  width: 0,
+  height: 0,
+  display: "flex",
+  overflow: "hidden",
+  opacity: 0,
+  border: 0,
+  padding: 0,
+  margin: 0
+}, ua = Ve({
+  compatConfig: {
+    MODE: 3
+  },
+  name: "OptionList",
+  inheritAttrs: !1,
+  setup(e, s) {
+    let {
+      slots: l,
+      expose: t
+    } = s;
+    const a = Ot(), n = Ht(), o = ca(), r = fe(), d = Rt(() => o.treeData, [() => a.open, () => o.treeData], (v) => v[0]), c = y(() => {
+      const {
+        checkable: v,
+        halfCheckedKeys: V,
+        checkedKeys: E
+      } = n;
+      return v ? {
+        checked: E,
+        halfChecked: V
+      } : null;
+    });
+    be(() => a.open, () => {
+      mt(() => {
+        var v;
+        a.open && !a.multiple && n.checkedKeys.length && ((v = r.value) === null || v === void 0 || v.scrollTo({
+          key: n.checkedKeys[0]
+        }));
+      });
+    }, {
+      immediate: !0,
+      flush: "post"
+    });
+    const i = y(() => String(a.searchValue).toLowerCase()), f = (v) => i.value ? String(v[n.treeNodeFilterProp]).toLowerCase().includes(i.value) : !1, m = M(n.treeDefaultExpandedKeys), w = M(null);
+    be(() => a.searchValue, () => {
+      a.searchValue && (w.value = ra(ae(o.treeData), ae(o.fieldNames)));
+    }, {
+      immediate: !0
+    });
+    const x = y(() => n.treeExpandedKeys ? n.treeExpandedKeys.slice() : a.searchValue ? w.value : m.value), S = (v) => {
+      var V;
+      m.value = v, w.value = v, (V = n.onTreeExpand) === null || V === void 0 || V.call(n, v);
+    }, g = (v) => {
+      v.preventDefault();
+    }, F = (v, V) => {
+      let {
+        node: E
+      } = V;
+      var D, T;
+      const {
+        checkable: z,
+        checkedKeys: Y
+      } = n;
+      z && Ye(E) || ((D = o.onSelect) === null || D === void 0 || D.call(o, E.key, {
+        selected: !Y.includes(E.key)
+      }), a.multiple || (T = a.toggleOpen) === null || T === void 0 || T.call(a, !1));
+    }, A = fe(null), K = y(() => n.keyEntities[A.value]), O = (v) => {
+      A.value = v;
+    };
+    return t({
+      scrollTo: function() {
+        for (var v, V, E = arguments.length, D = new Array(E), T = 0; T < E; T++)
+          D[T] = arguments[T];
+        return (V = (v = r.value) === null || v === void 0 ? void 0 : v.scrollTo) === null || V === void 0 ? void 0 : V.call(v, ...D);
+      },
+      onKeydown: (v) => {
+        var V;
+        const {
+          which: E
+        } = v;
+        switch (E) {
+          case de.UP:
+          case de.DOWN:
+          case de.LEFT:
+          case de.RIGHT:
+            (V = r.value) === null || V === void 0 || V.onKeydown(v);
+            break;
+          case de.ENTER: {
+            if (K.value) {
+              const {
+                selectable: D,
+                value: T
+              } = K.value.node || {};
+              D !== !1 && F(null, {
+                node: {
+                  key: A.value
+                },
+                selected: !n.checkedKeys.includes(T)
+              });
+            }
+            break;
+          }
+          case de.ESC:
+            a.toggleOpen(!1);
+        }
+      },
+      onKeyup: () => {
+      }
+    }), () => {
+      var v;
+      const {
+        prefixCls: V,
+        multiple: E,
+        searchValue: D,
+        open: T,
+        notFoundContent: z = (v = l.notFoundContent) === null || v === void 0 ? void 0 : v.call(l)
+      } = a, {
+        listHeight: Y,
+        listItemHeight: B,
+        virtual: le,
+        dropdownMatchSelectWidth: q,
+        treeExpandAction: re
+      } = o, {
+        checkable: se,
+        treeDefaultExpandAll: ce,
+        treeIcon: ne,
+        showTreeIcon: G,
+        switcherIcon: pe,
+        treeLine: me,
+        loadData: ge,
+        treeLoadedKeys: ie,
+        treeMotion: C,
+        onTreeLoad: _,
+        checkedKeys: H
+      } = n;
+      if (d.value.length === 0)
+        return U("div", {
+          role: "listbox",
+          class: `${V}-empty`,
+          onMousedown: g
+        }, [z]);
+      const Q = {
+        fieldNames: o.fieldNames
+      };
+      return ie && (Q.loadedKeys = ie), x.value && (Q.expandedKeys = x.value), U("div", {
+        onMousedown: g
+      }, [K.value && T && U("span", {
+        style: ia,
+        "aria-live": "assertive"
+      }, [K.value.node.value]), U(zt, X(X({
+        ref: r,
+        focusable: !1,
+        prefixCls: `${V}-tree`,
+        treeData: d.value,
+        height: Y,
+        itemHeight: B,
+        virtual: le !== !1 && q !== !1,
+        multiple: E,
+        icon: ne,
+        showIcon: G,
+        switcherIcon: pe,
+        showLine: me,
+        loadData: D ? null : ge,
+        motion: C,
+        activeKey: A.value,
+        checkable: se,
+        checkStrictly: !0,
+        checkedKeys: c.value,
+        selectedKeys: se ? [] : H,
+        defaultExpandAll: ce
+      }, Q), {}, {
+        onActiveChange: O,
+        onSelect: F,
+        onCheck: F,
+        onExpand: S,
+        onLoad: _,
+        filterTreeNode: f,
+        expandAction: re
+      }), b(b({}, l), {
+        checkable: n.customSlots.treeCheckable
+      }))]);
+    };
+  }
+}), da = "SHOW_ALL", vt = "SHOW_PARENT", Qe = "SHOW_CHILD";
+function ot(e, s, l, t) {
+  const a = new Set(e);
+  return s === Qe ? e.filter((n) => {
+    const o = l[n];
+    return !(o && o.children && o.children.some((r) => {
+      let {
+        node: d
+      } = r;
+      return a.has(d[t.value]);
+    }) && o.children.every((r) => {
+      let {
+        node: d
+      } = r;
+      return Ye(d) || a.has(d[t.value]);
+    }));
+  }) : s === vt ? e.filter((n) => {
+    const o = l[n], r = o ? o.parent : null;
+    return !(r && !Ye(r.node) && a.has(r.key));
+  }) : e;
+}
+const he = () => null;
+he.inheritAttrs = !1;
+he.displayName = "ATreeSelectNode";
+he.isTreeSelectNode = !0;
+var va = function(e, s) {
+  var l = {};
+  for (var t in e) Object.prototype.hasOwnProperty.call(e, t) && s.indexOf(t) < 0 && (l[t] = e[t]);
+  if (e != null && typeof Object.getOwnPropertySymbols == "function") for (var a = 0, t = Object.getOwnPropertySymbols(e); a < t.length; a++)
+    s.indexOf(t[a]) < 0 && Object.prototype.propertyIsEnumerable.call(e, t[a]) && (l[t[a]] = e[t[a]]);
+  return l;
+};
+function fa(e) {
+  return e && e.type && e.type.isTreeSelectNode;
+}
+function ha(e) {
+  function s() {
+    let l = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+    return xt(l).map((t) => {
+      var a, n, o;
+      if (!fa(t))
+        return null;
+      const r = t.children || {}, d = t.key, c = {};
+      for (const [E, D] of Object.entries(t.props))
+        c[Vt(E)] = D;
+      const {
+        isLeaf: i,
+        checkable: f,
+        selectable: m,
+        disabled: w,
+        disableCheckbox: x
+      } = c, S = {
+        isLeaf: i || i === "" || void 0,
+        checkable: f || f === "" || void 0,
+        selectable: m || m === "" || void 0,
+        disabled: w || w === "" || void 0,
+        disableCheckbox: x || x === "" || void 0
+      }, g = b(b({}, c), S), {
+        title: F = (a = r.title) === null || a === void 0 ? void 0 : a.call(r, g),
+        switcherIcon: A = (n = r.switcherIcon) === null || n === void 0 ? void 0 : n.call(r, g)
+      } = c, K = va(c, ["title", "switcherIcon"]), O = (o = r.default) === null || o === void 0 ? void 0 : o.call(r), v = b(b(b({}, K), {
+        title: F,
+        switcherIcon: A,
+        key: d,
+        isLeaf: i
+      }), S), V = s(O);
+      return V.length && (v.children = V), v;
+    });
+  }
+  return s(e);
+}
+function qe(e) {
+  if (!e)
+    return e;
+  const s = b({}, e);
+  return "props" in s || Object.defineProperty(s, "props", {
+    get() {
+      return s;
+    }
+  }), s;
+}
+function pa(e, s, l, t, a, n) {
+  let o = null, r = null;
+  function d() {
+    function c(i) {
+      let f = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "0", m = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : !1;
+      return i.map((w, x) => {
+        const S = `${f}-${x}`, g = w[n.value], F = l.includes(g), A = c(w[n.children] || [], S, F), K = U(he, w, {
+          default: () => [A.map((O) => O.node)]
+        });
+        if (s === g && (o = K), F) {
+          const O = {
+            pos: S,
+            node: K,
+            children: A
+          };
+          return m || r.push(O), O;
+        }
+        return null;
+      }).filter((w) => w);
+    }
+    r || (r = [], c(t), r.sort((i, f) => {
+      let {
+        node: {
+          props: {
+            value: m
+          }
+        }
+      } = i, {
+        node: {
+          props: {
+            value: w
+          }
+        }
+      } = f;
+      const x = l.indexOf(m), S = l.indexOf(w);
+      return x - S;
+    }));
+  }
+  Object.defineProperty(e, "triggerNode", {
+    get() {
+      return d(), o;
+    }
+  }), Object.defineProperty(e, "allCheckedNodes", {
+    get() {
+      return d(), a ? r : r.map((c) => {
+        let {
+          node: i
+        } = c;
+        return i;
+      });
+    }
+  });
+}
+function ma(e, s) {
+  let {
+    id: l,
+    pId: t,
+    rootPId: a
+  } = s;
+  const n = {}, o = [];
+  return e.map((d) => {
+    const c = b({}, d), i = c[l];
+    return n[i] = c, c.key = c.key || i, c;
+  }).forEach((d) => {
+    const c = d[t], i = n[c];
+    i && (i.children = i.children || [], i.children.push(d)), (c === a || !i && a === null) && o.push(d);
+  }), o;
+}
+function ga(e, s, l) {
+  const t = M();
+  return be([l, e, s], () => {
+    const a = l.value;
+    e.value ? t.value = l.value ? ma(ae(e.value), b({
+      id: "id",
+      pId: "pId",
+      rootPId: null
+    }, a !== !0 ? a : {})) : ae(e.value).slice() : t.value = ha(ae(s.value));
+  }, {
+    immediate: !0,
+    deep: !0
+  }), t;
+}
+const ya = (e) => {
+  const s = M({
+    valueLabels: /* @__PURE__ */ new Map()
+  }), l = M();
+  return be(e, () => {
+    l.value = ae(e.value);
+  }, {
+    immediate: !0
+  }), [y(() => {
+    const {
+      valueLabels: a
+    } = s.value, n = /* @__PURE__ */ new Map(), o = l.value.map((r) => {
+      var d;
+      const {
+        value: c
+      } = r, i = (d = r.label) !== null && d !== void 0 ? d : a.get(c);
+      return n.set(c, i), b(b({}, r), {
+        label: i
+      });
+    });
+    return s.value.valueLabels = n, o;
+  })];
+}, ba = (e, s) => {
+  const l = M(/* @__PURE__ */ new Map()), t = M({});
+  return Ge(() => {
+    const a = s.value, n = Xt(e.value, {
+      fieldNames: a,
+      initWrapper: (o) => b(b({}, o), {
+        valueEntities: /* @__PURE__ */ new Map()
+      }),
+      processEntity: (o, r) => {
+        const d = o.node[a.value];
+        r.valueEntities.set(d, o);
+      }
+    });
+    l.value = n.valueEntities, t.value = n.keyEntities;
+  }), {
+    valueEntities: l,
+    keyEntities: t
+  };
+}, Ca = (e, s, l, t, a, n) => {
+  const o = M([]), r = M([]);
+  return Ge(() => {
+    let d = e.value.map((f) => {
+      let {
+        value: m
+      } = f;
+      return m;
+    }), c = s.value.map((f) => {
+      let {
+        value: m
+      } = f;
+      return m;
+    });
+    const i = d.filter((f) => !t.value[f]);
+    l.value && ({
+      checkedKeys: d,
+      halfCheckedKeys: c
+    } = Xe(d, !0, t.value, a.value, n.value)), o.value = Array.from(/* @__PURE__ */ new Set([...i, ...d])), r.value = c;
+  }), [o, r];
+}, Sa = (e, s, l) => {
+  let {
+    treeNodeFilterProp: t,
+    filterTreeNode: a,
+    fieldNames: n
+  } = l;
+  return y(() => {
+    const {
+      children: o
+    } = n.value, r = s.value, d = t == null ? void 0 : t.value;
+    if (!r || a.value === !1)
+      return e.value;
+    let c;
+    if (typeof a.value == "function")
+      c = a.value;
+    else {
+      const f = r.toUpperCase();
+      c = (m, w) => {
+        const x = w[d];
+        return String(x).toUpperCase().includes(f);
+      };
+    }
+    function i(f) {
+      let m = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !1;
+      const w = [];
+      for (let x = 0, S = f.length; x < S; x++) {
+        const g = f[x], F = g[o], A = m || c(r, qe(g)), K = i(F || [], A);
+        (A || K.length) && w.push(b(b({}, g), {
+          [o]: K
+        }));
+      }
+      return w;
+    }
+    return i(e.value);
+  });
+};
+function ft() {
+  return b(b({}, Ie(jt(), ["mode"])), {
+    prefixCls: String,
+    id: String,
+    value: {
+      type: [String, Number, Object, Array]
+    },
+    defaultValue: {
+      type: [String, Number, Object, Array]
+    },
+    onChange: {
+      type: Function
+    },
+    searchValue: String,
+    /** @deprecated Use `searchValue` instead */
+    inputValue: String,
+    onSearch: {
+      type: Function
+    },
+    autoClearSearchValue: {
+      type: Boolean,
+      default: void 0
+    },
+    filterTreeNode: {
+      type: [Boolean, Function],
+      default: void 0
+    },
+    treeNodeFilterProp: String,
+    // >>> Select
+    onSelect: Function,
+    onDeselect: Function,
+    showCheckedStrategy: {
+      type: String
+    },
+    treeNodeLabelProp: String,
+    fieldNames: {
+      type: Object
+    },
+    // >>> Mode
+    multiple: {
+      type: Boolean,
+      default: void 0
+    },
+    treeCheckable: {
+      type: Boolean,
+      default: void 0
+    },
+    treeCheckStrictly: {
+      type: Boolean,
+      default: void 0
+    },
+    labelInValue: {
+      type: Boolean,
+      default: void 0
+    },
+    // >>> Data
+    treeData: {
+      type: Array
+    },
+    treeDataSimpleMode: {
+      type: [Boolean, Object],
+      default: void 0
+    },
+    loadData: {
+      type: Function
+    },
+    treeLoadedKeys: {
+      type: Array
+    },
+    onTreeLoad: {
+      type: Function
+    },
+    // >>> Expanded
+    treeDefaultExpandAll: {
+      type: Boolean,
+      default: void 0
+    },
+    treeExpandedKeys: {
+      type: Array
+    },
+    treeDefaultExpandedKeys: {
+      type: Array
+    },
+    onTreeExpand: {
+      type: Function
+    },
+    // >>> Options
+    virtual: {
+      type: Boolean,
+      default: void 0
+    },
+    listHeight: Number,
+    listItemHeight: Number,
+    onDropdownVisibleChange: {
+      type: Function
+    },
+    // >>> Tree
+    treeLine: {
+      type: [Boolean, Object],
+      default: void 0
+    },
+    treeIcon: ve.any,
+    showTreeIcon: {
+      type: Boolean,
+      default: void 0
+    },
+    switcherIcon: ve.any,
+    treeMotion: ve.any,
+    children: Array,
+    treeExpandAction: String,
+    showArrow: {
+      type: Boolean,
+      default: void 0
+    },
+    showSearch: {
+      type: Boolean,
+      default: void 0
+    },
+    open: {
+      type: Boolean,
+      default: void 0
+    },
+    defaultOpen: {
+      type: Boolean,
+      default: void 0
+    },
+    disabled: {
+      type: Boolean,
+      default: void 0
+    },
+    placeholder: ve.any,
+    maxTagPlaceholder: {
+      type: Function
+    },
+    dropdownPopupAlign: ve.any,
+    customSlots: Object
+  });
+}
+function wa(e) {
+  return !e || typeof e != "object";
+}
+const xa = Ve({
+  compatConfig: {
+    MODE: 3
+  },
+  name: "TreeSelect",
+  inheritAttrs: !1,
+  props: it(ft(), {
+    treeNodeFilterProp: "value",
+    autoClearSearchValue: !0,
+    showCheckedStrategy: Qe,
+    listHeight: 200,
+    listItemHeight: 20,
+    prefixCls: "vc-tree-select"
+  }),
+  setup(e, s) {
+    let {
+      attrs: l,
+      expose: t,
+      slots: a
+    } = s;
+    const n = Mt(oe(e, "id")), o = y(() => e.treeCheckable && !e.treeCheckStrictly), r = y(() => e.treeCheckable || e.treeCheckStrictly), d = y(() => e.treeCheckStrictly || e.labelInValue), c = y(() => r.value || e.multiple), i = y(() => oa(e.fieldNames)), [f, m] = tt("", {
+      value: y(() => e.searchValue !== void 0 ? e.searchValue : e.inputValue),
+      postState: (u) => u || ""
+    }), w = (u) => {
+      var h;
+      m(u), (h = e.onSearch) === null || h === void 0 || h.call(e, u);
+    }, x = ga(oe(e, "treeData"), oe(e, "children"), oe(e, "treeDataSimpleMode")), {
+      keyEntities: S,
+      valueEntities: g
+    } = ba(x, i), F = (u) => {
+      const h = [], p = [];
+      return u.forEach((k) => {
+        g.value.has(k) ? p.push(k) : h.push(k);
+      }), {
+        missingRawValues: h,
+        existRawValues: p
+      };
+    }, A = Sa(x, f, {
+      fieldNames: i,
+      treeNodeFilterProp: oe(e, "treeNodeFilterProp"),
+      filterTreeNode: oe(e, "filterTreeNode")
+    }), K = (u) => {
+      if (u) {
+        if (e.treeNodeLabelProp)
+          return u[e.treeNodeLabelProp];
+        const {
+          _title: h
+        } = i.value;
+        for (let p = 0; p < h.length; p += 1) {
+          const k = u[h[p]];
+          if (k !== void 0)
+            return k;
+        }
+      }
+    }, O = (u) => na(u).map((p) => wa(p) ? {
+      value: p
+    } : p), v = (u) => O(u).map((p) => {
+      let {
+        label: k
+      } = p;
+      const {
+        value: P,
+        halfChecked: L
+      } = p;
+      let I;
+      const N = g.value.get(P);
+      return N && (k = k ?? K(N.node), I = N.node.disabled), {
+        label: k,
+        value: P,
+        halfChecked: L,
+        disabled: I
+      };
+    }), [V, E] = tt(e.defaultValue, {
+      value: oe(e, "value")
+    }), D = y(() => O(V.value)), T = M([]), z = M([]);
+    Ge(() => {
+      const u = [], h = [];
+      D.value.forEach((p) => {
+        p.halfChecked ? h.push(p) : u.push(p);
+      }), T.value = u, z.value = h;
+    });
+    const Y = y(() => T.value.map((u) => u.value)), {
+      maxLevel: B,
+      levelEntities: le
+    } = Yt(S), [q, re] = Ca(T, z, o, S, B, le), se = y(() => {
+      const p = ot(q.value, e.showCheckedStrategy, S.value, i.value).map((L) => {
+        var I, N, R;
+        return (R = (N = (I = S.value[L]) === null || I === void 0 ? void 0 : I.node) === null || N === void 0 ? void 0 : N[i.value.value]) !== null && R !== void 0 ? R : L;
+      }).map((L) => {
+        const I = T.value.find((N) => N.value === L);
+        return {
+          value: L,
+          label: I == null ? void 0 : I.label
+        };
+      }), k = v(p), P = k[0];
+      return !c.value && P && nt(P.value) && nt(P.label) ? [] : k.map((L) => {
+        var I;
+        return b(b({}, L), {
+          label: (I = L.label) !== null && I !== void 0 ? I : L.value
+        });
+      });
+    }), [ce] = ya(se), ne = (u, h, p) => {
+      const k = v(u);
+      if (E(k), e.autoClearSearchValue && m(""), e.onChange) {
+        let P = u;
+        o.value && (P = ot(u, e.showCheckedStrategy, S.value, i.value).map((te) => {
+          const Se = g.value.get(te);
+          return Se ? Se.node[i.value.value] : te;
+        }));
+        const {
+          triggerValue: L,
+          selected: I
+        } = h || {
+          triggerValue: void 0,
+          selected: void 0
+        };
+        let N = P;
+        if (e.treeCheckStrictly) {
+          const j = z.value.filter((te) => !P.includes(te.value));
+          N = [...N, ...j];
+        }
+        const R = v(N), Z = {
+          // [Legacy] Always return as array contains label & value
+          preValue: T.value,
+          triggerValue: L
+        };
+        let ee = !0;
+        (e.treeCheckStrictly || p === "selection" && !I) && (ee = !1), pa(Z, L, u, x.value, ee, i.value), r.value ? Z.checked = I : Z.selected = I;
+        const $ = d.value ? R : R.map((j) => j.value);
+        e.onChange(c.value ? $ : $[0], d.value ? null : R.map((j) => j.label), Z);
+      }
+    }, G = (u, h) => {
+      let {
+        selected: p,
+        source: k
+      } = h;
+      var P, L, I;
+      const N = ae(S.value), R = ae(g.value), Z = N[u], ee = Z == null ? void 0 : Z.node, $ = (P = ee == null ? void 0 : ee[i.value.value]) !== null && P !== void 0 ? P : u;
+      if (!c.value)
+        ne([$], {
+          selected: !0,
+          triggerValue: $
+        }, "option");
+      else {
+        let j = p ? [...Y.value, $] : q.value.filter((te) => te !== $);
+        if (o.value) {
+          const {
+            missingRawValues: te,
+            existRawValues: Se
+          } = F(j), Je = Se.map((Re) => R.get(Re).key);
+          let He;
+          p ? {
+            checkedKeys: He
+          } = Xe(Je, !0, N, B.value, le.value) : {
+            checkedKeys: He
+          } = Xe(Je, {
+            checked: !1,
+            halfCheckedKeys: re.value
+          }, N, B.value, le.value), j = [...te, ...He.map((Re) => N[Re].node[i.value.value])];
+        }
+        ne(j, {
+          selected: p,
+          triggerValue: $
+        }, k || "option");
+      }
+      p || !c.value ? (L = e.onSelect) === null || L === void 0 || L.call(e, $, qe(ee)) : (I = e.onDeselect) === null || I === void 0 || I.call(e, $, qe(ee));
+    }, pe = (u) => {
+      if (e.onDropdownVisibleChange) {
+        const h = {};
+        Object.defineProperty(h, "documentClickClose", {
+          get() {
+            return !1;
+          }
+        }), e.onDropdownVisibleChange(u, h);
+      }
+    }, me = (u, h) => {
+      const p = u.map((k) => k.value);
+      if (h.type === "clear") {
+        ne(p, {}, "selection");
+        return;
+      }
+      h.values.length && G(h.values[0].value, {
+        selected: !1,
+        source: "selection"
+      });
+    }, {
+      treeNodeFilterProp: ge,
+      // Data
+      loadData: ie,
+      treeLoadedKeys: C,
+      onTreeLoad: _,
+      // Expanded
+      treeDefaultExpandAll: H,
+      treeExpandedKeys: Q,
+      treeDefaultExpandedKeys: ke,
+      onTreeExpand: Ne,
+      // Options
+      virtual: Te,
+      listHeight: Le,
+      listItemHeight: Ee,
+      // Tree
+      treeLine: _e,
+      treeIcon: Ce,
+      showTreeIcon: Pe,
+      switcherIcon: De,
+      treeMotion: Ae,
+      customSlots: Ke,
+      dropdownMatchSelectWidth: Fe,
+      treeExpandAction: Oe
+    } = gt(e);
+    Bt(lt({
+      checkable: r,
+      loadData: ie,
+      treeLoadedKeys: C,
+      onTreeLoad: _,
+      checkedKeys: q,
+      halfCheckedKeys: re,
+      treeDefaultExpandAll: H,
+      treeExpandedKeys: Q,
+      treeDefaultExpandedKeys: ke,
+      onTreeExpand: Ne,
+      treeIcon: Ce,
+      treeMotion: Ae,
+      showTreeIcon: Pe,
+      switcherIcon: De,
+      treeLine: _e,
+      treeNodeFilterProp: ge,
+      keyEntities: S,
+      customSlots: Ke
+    })), sa(lt({
+      virtual: Te,
+      listHeight: Le,
+      listItemHeight: Ee,
+      treeData: A,
+      fieldNames: i,
+      onSelect: G,
+      dropdownMatchSelectWidth: Fe,
+      treeExpandAction: Oe
+    }));
+    const J = fe();
+    return t({
+      focus() {
+        var u;
+        (u = J.value) === null || u === void 0 || u.focus();
+      },
+      blur() {
+        var u;
+        (u = J.value) === null || u === void 0 || u.blur();
+      },
+      scrollTo(u) {
+        var h;
+        (h = J.value) === null || h === void 0 || h.scrollTo(u);
+      }
+    }), () => {
+      var u;
+      const h = Ie(e, [
+        "id",
+        "prefixCls",
+        "customSlots",
+        // Value
+        "value",
+        "defaultValue",
+        "onChange",
+        "onSelect",
+        "onDeselect",
+        // Search
+        "searchValue",
+        "inputValue",
+        "onSearch",
+        "autoClearSearchValue",
+        "filterTreeNode",
+        "treeNodeFilterProp",
+        // Selector
+        "showCheckedStrategy",
+        "treeNodeLabelProp",
+        //  Mode
+        "multiple",
+        "treeCheckable",
+        "treeCheckStrictly",
+        "labelInValue",
+        // FieldNames
+        "fieldNames",
+        // Data
+        "treeDataSimpleMode",
+        "treeData",
+        "children",
+        "loadData",
+        "treeLoadedKeys",
+        "onTreeLoad",
+        // Expanded
+        "treeDefaultExpandAll",
+        "treeExpandedKeys",
+        "treeDefaultExpandedKeys",
+        "onTreeExpand",
+        // Options
+        "virtual",
+        "listHeight",
+        "listItemHeight",
+        "onDropdownVisibleChange",
+        // Tree
+        "treeLine",
+        "treeIcon",
+        "showTreeIcon",
+        "switcherIcon",
+        "treeMotion"
+      ]);
+      return U($t, X(X(X({
+        ref: J
+      }, l), h), {}, {
+        id: n,
+        prefixCls: e.prefixCls,
+        mode: c.value ? "multiple" : void 0,
+        displayValues: ce.value,
+        onDisplayValuesChange: me,
+        searchValue: f.value,
+        onSearch: w,
+        OptionList: ua,
+        emptyOptions: !x.value.length,
+        onDropdownVisibleChange: pe,
+        tagRender: e.tagRender || a.tagRender,
+        dropdownMatchSelectWidth: (u = e.dropdownMatchSelectWidth) !== null && u !== void 0 ? u : !0
+      }), a);
+    };
+  }
+}), Va = (e) => {
+  const {
+    componentCls: s,
+    treePrefixCls: l,
+    colorBgElevated: t
+  } = e, a = `.${l}`;
+  return [
+    // ======================================================
+    // ==                     Dropdown                     ==
+    // ======================================================
+    {
+      [`${s}-dropdown`]: [
+        {
+          padding: `${e.paddingXS}px ${e.paddingXS / 2}px`
+        },
+        // ====================== Tree ======================
+        qt(l, ut(e, {
+          colorBgContainer: t
+        })),
+        {
+          [a]: {
+            borderRadius: 0,
+            "&-list-holder-inner": {
+              alignItems: "stretch",
+              [`${a}-treenode`]: {
+                [`${a}-node-content-wrapper`]: {
+                  flex: "auto"
+                }
+              }
+            }
+          }
+        },
+        // ==================== Checkbox ====================
+        Gt(`${l}-checkbox`, e),
+        // ====================== RTL =======================
+        {
+          "&-rtl": {
+            direction: "rtl",
+            [`${a}-switcher${a}-switcher_close`]: {
+              [`${a}-switcher-icon svg`]: {
+                transform: "rotate(90deg)"
+              }
+            }
+          }
+        }
+      ]
+    }
+  ];
+};
+function Ia(e, s) {
+  return It("TreeSelect", (l) => {
+    const t = ut(l, {
+      treePrefixCls: s.value
+    });
+    return [Va(t)];
+  })(e);
+}
+const rt = (e, s, l) => l !== void 0 ? l : `${e}-${s}`;
+function ka() {
+  return b(b({}, Ie(ft(), ["showTreeIcon", "treeMotion", "inputIcon", "getInputElement", "treeLine", "customSlots"])), {
+    suffixIcon: ve.any,
+    size: je(),
+    bordered: Pt(),
+    treeLine: Dt([Boolean, Object]),
+    replaceFields: At(),
+    placement: je(),
+    status: je(),
+    popupClassName: String,
+    /** @deprecated Please use `popupClassName` instead */
+    dropdownClassName: String,
+    "onUpdate:value": We(),
+    "onUpdate:treeExpandedKeys": We(),
+    "onUpdate:searchValue": We()
+  });
+}
+const Ue = Ve({
+  compatConfig: {
+    MODE: 3
+  },
+  name: "ATreeSelect",
+  inheritAttrs: !1,
+  props: it(ka(), {
+    choiceTransitionName: "",
+    listHeight: 256,
+    treeIcon: !1,
+    listItemHeight: 26,
+    bordered: !0
+  }),
+  slots: Object,
+  setup(e, s) {
+    let {
+      attrs: l,
+      slots: t,
+      expose: a,
+      emit: n
+    } = s;
+    kt(!(e.treeData === void 0 && t.default)), $e(e.multiple !== !1 || !e.treeCheckable, "TreeSelect", "`multiple` will always be `true` when `treeCheckable` is true"), $e(e.replaceFields === void 0, "TreeSelect", "`replaceFields` is deprecated, please use fieldNames instead"), $e(!e.dropdownClassName, "TreeSelect", "`dropdownClassName` is deprecated. Please use `popupClassName` instead.");
+    const o = Qt(), r = Jt.useInject(), d = y(() => Zt(r.status, e.status)), {
+      prefixCls: c,
+      renderEmpty: i,
+      direction: f,
+      virtual: m,
+      dropdownMatchSelectWidth: w,
+      size: x,
+      getPopupContainer: S,
+      getPrefixCls: g,
+      disabled: F
+    } = Nt("select", e), {
+      compactSize: A,
+      compactItemClassnames: K
+    } = Tt(c, f), O = y(() => A.value || x.value), v = Lt(), V = y(() => {
+      var C;
+      return (C = F.value) !== null && C !== void 0 ? C : v.value;
+    }), E = y(() => g()), D = y(() => e.placement !== void 0 ? e.placement : f.value === "rtl" ? "bottomRight" : "bottomLeft"), T = y(() => rt(E.value, Et(D.value), e.transitionName)), z = y(() => rt(E.value, "", e.choiceTransitionName)), Y = y(() => g("select-tree", e.prefixCls)), B = y(() => g("tree-select", e.prefixCls)), [le, q] = Wt(c), [re] = Ia(B, Y), se = y(() => at(e.popupClassName || e.dropdownClassName, `${B.value}-dropdown`, {
+      [`${B.value}-dropdown-rtl`]: f.value === "rtl"
+    }, q.value)), ce = y(() => !!(e.treeCheckable || e.multiple)), ne = y(() => e.showArrow !== void 0 ? e.showArrow : e.loading || !ce.value), G = fe();
+    a({
+      focus() {
+        var C, _;
+        (_ = (C = G.value).focus) === null || _ === void 0 || _.call(C);
+      },
+      blur() {
+        var C, _;
+        (_ = (C = G.value).blur) === null || _ === void 0 || _.call(C);
+      }
+    });
+    const pe = function() {
+      for (var C = arguments.length, _ = new Array(C), H = 0; H < C; H++)
+        _[H] = arguments[H];
+      n("update:value", _[0]), n("change", ..._), o.onFieldChange();
+    }, me = (C) => {
+      n("update:treeExpandedKeys", C), n("treeExpand", C);
+    }, ge = (C) => {
+      n("update:searchValue", C), n("search", C);
+    }, ie = (C) => {
+      n("blur", C), o.onFieldBlur();
+    };
+    return () => {
+      var C, _, H;
+      const {
+        notFoundContent: Q = (C = t.notFoundContent) === null || C === void 0 ? void 0 : C.call(t),
+        prefixCls: ke,
+        bordered: Ne,
+        listHeight: Te,
+        listItemHeight: Le,
+        multiple: Ee,
+        treeIcon: _e,
+        treeLine: Ce,
+        showArrow: Pe,
+        switcherIcon: De = (_ = t.switcherIcon) === null || _ === void 0 ? void 0 : _.call(t),
+        fieldNames: Ae = e.replaceFields,
+        id: Ke = o.id.value,
+        placeholder: Fe = (H = t.placeholder) === null || H === void 0 ? void 0 : H.call(t)
+      } = e, {
+        isFormItemInput: Oe,
+        hasFeedback: J,
+        feedbackIcon: u
+      } = r, {
+        suffixIcon: h,
+        removeIcon: p,
+        clearIcon: k
+      } = Ut(b(b({}, e), {
+        multiple: ce.value,
+        showArrow: ne.value,
+        hasFeedback: J,
+        feedbackIcon: u,
+        prefixCls: c.value
+      }), t);
+      let P;
+      Q !== void 0 ? P = Q : P = i("Select");
+      const L = Ie(e, ["suffixIcon", "itemIcon", "removeIcon", "clearIcon", "switcherIcon", "bordered", "status", "onUpdate:value", "onUpdate:treeExpandedKeys", "onUpdate:searchValue"]), I = at(!ke && B.value, {
+        [`${c.value}-lg`]: O.value === "large",
+        [`${c.value}-sm`]: O.value === "small",
+        [`${c.value}-rtl`]: f.value === "rtl",
+        [`${c.value}-borderless`]: !Ne,
+        [`${c.value}-in-form-item`]: Oe
+      }, ea(c.value, d.value, J), K.value, l.class, q.value), N = {};
+      return e.treeData === void 0 && t.default && (N.children = _t(t.default())), le(re(U(xa, X(X(X(X({}, l), L), {}, {
+        disabled: V.value,
+        virtual: m.value,
+        dropdownMatchSelectWidth: w.value,
+        id: Ke,
+        fieldNames: Ae,
+        ref: G,
+        prefixCls: c.value,
+        class: I,
+        listHeight: Te,
+        listItemHeight: Le,
+        treeLine: !!Ce,
+        inputIcon: h,
+        multiple: Ee,
+        removeIcon: p,
+        clearIcon: k,
+        switcherIcon: (R) => ta(Y.value, De, R, t.leafIcon, Ce),
+        showTreeIcon: _e,
+        notFoundContent: P,
+        getPopupContainer: S == null ? void 0 : S.value,
+        treeMotion: null,
+        dropdownClassName: se.value,
+        choiceTransitionName: z.value,
+        onChange: pe,
+        onBlur: ie,
+        onSearch: ge,
+        onTreeExpand: me
+      }, N), {}, {
+        transitionName: T.value,
+        customSlots: b(b({}, t), {
+          treeCheckable: () => U("span", {
+            class: `${c.value}-tree-checkbox-inner`
+          }, null)
+        }),
+        maxTagPlaceholder: e.maxTagPlaceholder || t.maxTagPlaceholder,
+        placement: D.value,
+        showArrow: J || Pe,
+        placeholder: Fe
+      }), b(b({}, t), {
+        treeCheckable: () => U("span", {
+          class: `${c.value}-tree-checkbox-inner`
+        }, null)
+      }))));
+    };
+  }
+}), st = he, ct = b(Ue, {
+  TreeNode: he,
+  SHOW_ALL: da,
+  SHOW_PARENT: vt,
+  SHOW_CHILD: Qe,
+  install: (e) => (e.component(Ue.name, Ue), e.component(st.displayName, st), e)
+}), ze = yt({});
+function Na(e) {
+  return be(() => e, (s) => {
+    s.forEach(async (l) => {
+      if (!ze[l.id]) {
+        const t = await Kt.getCategoryValues(l.id), { flatAttributeValue: a, treeAttributeValue: n, showWay: o } = t.body;
+        ze[l.id] = o === "TREE" ? n : a;
+      }
+    });
+  }, { immediate: !0 }), {
+    categoryValuesMap: ze
+  };
+}
+const Ta = { class: "crane-required" }, La = { class: "crane-category-tips" }, Ea = {
+  key: 0,
+  style: { color: "#1677ff", "font-weight": "bold" }
+}, _a = { key: 1 }, Pa = {
+  key: 0,
+  style: { color: "#ff4d4f", "font-size": "12px" }
+}, Da = /* @__PURE__ */ Ve({
+  __name: "category-selector",
+  props: {
+    categoryList: {
+      type: Array,
+      default: () => []
+    }
+  },
+  setup(e, { expose: s }) {
+    const l = ct.SHOW_PARENT, t = e, a = y(() => ({
+      categoryList: t.categoryList
+    })), n = y(() => Object.values(d).some((i) => i.length > 0)), o = fe(), r = fe(""), { categoryValuesMap: d } = Na(t.categoryList);
+    return s({
+      validate: () => new Promise((i, f) => {
+        o.value.validate().then(() => {
+          i(!0);
+        }).catch(() => {
+          f(!1);
+        });
+      })
+    }), (i, f) => n.value ? (ue(), Ze(W(la), {
+      key: 0,
+      class: "crane-category-wraper",
+      model: a.value,
+      ref_key: "formRef",
+      ref: o
+    }, {
+      default: Me(() => [
+        Be("div", Ta, ye(W(xe)("category")), 1),
+        Be("div", La, ye(W(xe)("categotySelectTips")), 1),
+        f[1] || (f[1] = Be("div", { class: "crane-category-line" }, null, -1)),
+        (ue(!0), we(bt, null, Ct(a.value.categoryList, (m, w) => {
+          var x;
+          return St((ue(), Ze(W(aa), {
+            key: m.id,
+            label: m.categoryName,
+            name: ["categoryList", w, "attributeValueIds_view"],
+            rules: [{ required: !0, message: W(xe)("pleaseChoose"), trigger: ["change", "blur"] }]
+          }, {
+            default: Me(() => {
+              var S;
+              return [
+                U(W(ct), {
+                  treeCheckable: "",
+                  treeDefaultExpandAll: "",
+                  "tree-data": W(d)[m.id],
+                  showSearch: "",
+                  allowClear: "",
+                  value: m.attributeValueIds_view,
+                  "onUpdate:value": (g) => m.attributeValueIds_view = g,
+                  treeNodeFilterProp: "attributeName",
+                  searchValue: r.value,
+                  "onUpdate:searchValue": f[0] || (f[0] = (g) => r.value = g),
+                  fieldNames: { label: "attributeName", value: "id" },
+                  treeNodeLabelProp: "attributeName",
+                  "show-checked-strategy": W(l)
+                }, {
+                  title: Me(({ attributeName: g }) => [
+                    r.value.toLowerCase() && g.includes(r.value.toLowerCase()) ? (ue(), we("span", Ea, ye(g), 1)) : (ue(), we("span", _a, ye(g), 1))
+                  ]),
+                  _: 2
+                }, 1032, ["tree-data", "value", "onUpdate:value", "searchValue", "show-checked-strategy"]),
+                (S = m.attributeValueIds_view) != null && S.includes(-1) ? (ue(), we("span", Pa, ye(W(xe)("categoryChangeTips")), 1)) : et("", !0)
+              ];
+            }),
+            _: 2
+          }, 1032, ["label", "name", "rules"])), [
+            [wt, (x = W(d)[m.id]) == null ? void 0 : x.length]
+          ]);
+        }), 128))
+      ]),
+      _: 1
+    }, 8, ["model"])) : et("", !0);
+  }
+}), Ha = /* @__PURE__ */ Ft(Da, [["__scopeId", "data-v-5bc5b7db"]]);
+export {
+  Ha as default
+};