@yqg/permission 1.3.12 → 1.3.14-beta.1

package/dist/category-selector-CeFM3lr8.js

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