@yqg/permission 1.3.11 → 1.3.13

package/dist/category-selector-C-yZxEgO.js

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