hys-ui 0.1.0 → 0.2.0

package/dist/composables/useCascader.js

@@ -0,0 +1,438 @@
+import { ref as R, shallowRef as A, computed as s, watch as z, onBeforeUnmount as Te, onDeactivated as Le, onActivated as Re, nextTick as Ke } from "vue";
+import { useTreeSelect as Ne } from "./useTreeSelect.js";
+import { treeKey as $ } from "./tree.js";
+import { cascaderWords as K, cascaderEntries as I, cascaderToken as c, validCascaderPath as ve, cascaderPath as E } from "./cascader.js";
+function Je(t, G, f, h, ge) {
+  const w = R(!0), p = A(
+    t.defaultValue ?? (t.emitPath === !1 && !t.multiple ? null : [])
+  ), ee = A([
+    ...t.defaultExpandedPath ?? []
+  ]), N = A(), q = R(!1), D = A(), S = R(!1), x = A(), v = s(() => !!t.multiple), ae = s(
+    () => t.modelValue === void 0 ? p.value : t.modelValue
+  ), g = s(
+    () => !w.value || G.value || !!t.readonly || !!t.loading
+  ), me = s(() => {
+    var e, a, l, n;
+    return {
+      ...K,
+      ...t.locale,
+      search: t.searchPlaceholder ?? ((e = t.locale) == null ? void 0 : e.search) ?? K.search,
+      empty: t.emptyText ?? ((a = t.locale) == null ? void 0 : a.empty) ?? K.empty,
+      noMatch: t.noMatchText ?? ((l = t.locale) == null ? void 0 : l.noMatch) ?? K.noMatch,
+      loading: t.loadingText ?? ((n = t.locale) == null ? void 0 : n.loading) ?? K.loading
+    };
+  }), H = s(
+    () => !!t.checkStrictly || !v.value && !!t.changeOnSelect
+  ), _ = s(
+    () => I(N.value ?? t.options, t)
+  ), te = s(() => I(t.cacheData ?? [], t)), F = s(() => {
+    const e = new Map(te.value.map);
+    for (const [a, l] of _.value.map) e.set(a, l);
+    if (x.value)
+      for (const a of x.value.tree.index.value.rows)
+        e.set(String(a.key), a.node);
+    return e;
+  }), we = s(() => {
+    var n;
+    const e = /* @__PURE__ */ new Map();
+    for (const r of F.value.values())
+      e.has(r.path.at(-1)) || e.set(r.path.at(-1), r);
+    const a = ((n = x.value) == null ? void 0 : n.tree.index.value.rows.map(
+      (r) => r.node
+    )) ?? [..._.value.map.values()], l = /* @__PURE__ */ new Set();
+    for (const r of a) {
+      const u = r.path.at(-1);
+      l.has(u) || (e.set(u, r), l.add(u));
+    }
+    return e;
+  }), le = /* @__PURE__ */ new Map();
+  function ne(e) {
+    const a = we.value.get(e);
+    return a && le.set(e, a.path), (a == null ? void 0 : a.path) ?? le.get(e) ?? [e];
+  }
+  function re(e) {
+    return t.clearValue !== void 0 && JSON.stringify(e) === JSON.stringify(t.clearValue) ? [] : t.emitPath === !1 ? (v.value ? Array.isArray(e) ? e : $(e) ? [e] : [] : $(e) ? [e] : []).filter($).map(ne) : v.value ? Array.isArray(e) ? e.filter(ve).filter((a) => a.length).map((a) => [...a]) : [] : ve(e) && e.length ? [[...e]] : [];
+  }
+  const oe = s(() => re(ae.value)), j = s(() => oe.value.map(c)), y = s(() => [...t.expandedPath ?? ee.value]), ye = s(
+    () => y.value.map((e, a) => c(y.value.slice(0, a + 1)))
+  ), xe = s(
+    () => t.loadChildren ? async (e, a) => {
+      const l = await t.loadChildren(e.raw, {
+        signal: a.signal,
+        path: [...e.path],
+        nodes: [...e.nodes],
+        level: e.path.length - 1
+      });
+      if (!Array.isArray(l))
+        throw new TypeError("loadChildren must resolve to an array");
+      return I(l, t, e).roots;
+    } : void 0
+  );
+  function ie(e) {
+    var n;
+    const a = Array.isArray(e) ? e : typeof e == "string" && e ? [e] : [], l = a.filter((r) => typeof r == "string").map(E).filter((r) => r.length);
+    return !l.length && t.clearValue !== void 0 ? t.clearValue : v.value ? t.emitPath === !1 ? l.map((r) => r.at(-1)) : l : t.emitPath === !1 ? ((n = l[0]) == null ? void 0 : n.at(-1)) ?? null : l[0] ?? [];
+  }
+  function V(e) {
+    var u, d;
+    const a = (u = x.value) == null ? void 0 : u.item(e), l = F.value.get(e) ?? (a == null ? void 0 : a.node), n = (l == null ? void 0 : l.path) ?? E(e), r = (l == null ? void 0 : l.labels) ?? n.map(String);
+    return {
+      path: [...n],
+      labels: [...r],
+      nodes: [...(l == null ? void 0 : l.nodes) ?? []],
+      node: l == null ? void 0 : l.raw,
+      value: n.at(-1),
+      label: t.showAllLevels === !1 ? r.at(-1) ?? "" : r.join(t.separator ?? " / "),
+      disabled: !!(l != null && l.disabled || a != null && a.disabled),
+      missing: !((d = x.value) != null && d.tree.index.value.map.has(e))
+    };
+  }
+  function be(e) {
+    var l;
+    const a = e.values.filter(
+      (n) => typeof n == "string"
+    );
+    return {
+      reason: e.reason,
+      node: (l = e.node) == null ? void 0 : l.raw,
+      items: a.map(V),
+      paths: a.map(E),
+      halfCheckedPaths: e.halfCheckedKeys.map(
+        (n) => E(String(n))
+      ),
+      event: e.event
+    };
+  }
+  let m = 0, J = 0;
+  function Se(e) {
+    const a = [...y.value], l = m, n = e.map((u) => E(String(u))).sort((u, d) => d.length - u.length), r = n[0] ?? [];
+    t.expandedPath === void 0 && (ee.value = r), h("update:expandedPath", r), h(
+      "expandChange",
+      r,
+      r.flatMap((u, d) => {
+        var b;
+        const o = (b = F.value.get(
+          c(r.slice(0, d + 1))
+        )) == null ? void 0 : b.raw;
+        return o ? [o] : [];
+      })
+    ), Ke().then(() => {
+      var b;
+      if (!w.value || l !== m || c(y.value) !== c(r))
+        return;
+      const u = (W) => W.map((fe, Z) => c(W.slice(0, Z + 1))), d = new Set(u(a)), o = new Set(u(r));
+      for (const [W, fe, Z] of [
+        [d, o, "node-collapse"],
+        [o, d, "node-expand"]
+      ])
+        for (const he of W) {
+          const L = (b = x.value) == null ? void 0 : b.tree.index.value.map.get(he);
+          !fe.has(he) && (L != null && L.hasChildren) && h(Z, L.node.raw, { path: [...L.node.path] });
+        }
+    });
+  }
+  const i = Ne(
+    {
+      get nodes() {
+        return _.value.roots;
+      },
+      get cacheData() {
+        return te.value.roots;
+      },
+      get modelValue() {
+        return v.value ? j.value : j.value[0] ?? "";
+      },
+      get multiple() {
+        return v.value;
+      },
+      get checkable() {
+        return v.value;
+      },
+      get checkStrictly() {
+        return t.checkStrictly;
+      },
+      get showCheckedStrategy() {
+        return t.showCheckedStrategy ?? "child";
+      },
+      get disabled() {
+        return G.value;
+      },
+      get readonly() {
+        return t.readonly;
+      },
+      get loading() {
+        return t.loading;
+      },
+      get multipleLimit() {
+        return t.multipleLimit;
+      },
+      get searchValue() {
+        return t.searchValue;
+      },
+      get defaultSearchValue() {
+        return t.defaultSearchValue;
+      },
+      get expandedKeys() {
+        return ye.value;
+      },
+      autoExpandParent: !0,
+      accordion: !0,
+      get loadChildren() {
+        return xe.value;
+      },
+      get validateEvent() {
+        return t.validateEvent;
+      }
+    },
+    G,
+    f,
+    (e, ...a) => {
+      var l;
+      if (e === "update:modelValue") {
+        const n = ie(a[0]);
+        t.modelValue === void 0 && (p.value = n), h(e, n);
+      } else if (e === "change" || e === "value-change")
+        h(e, ie(a[0]), be(a[1])), e === "value-change" && t.clearSearchAfterSelect !== !1 && !t.retainSearch && i.filter("");
+      else if (e === "update:expandedKeys") Se(a[0]);
+      else if (e === "load" || e === "children-loaded") {
+        const n = a[0];
+        h(e, {
+          node: n.node.raw,
+          path: [...n.node.path],
+          children: n.children.map((r) => r.raw)
+        });
+      } else e === "load-error" ? h(e, {
+        node: a[0].node.raw,
+        path: [...a[0].node.path],
+        error: a[0].error
+      }) : e === "node-expand" || e === "node-collapse" ? h(e, a[0].raw, { path: [...a[0].path] }) : e === "remove-tag" ? h(e, E(String(a[0])), (l = a[1]) == null ? void 0 : l.raw) : ["update:searchValue", "search", "clear", "limit"].includes(e) && h(e, ...a);
+    },
+    ge
+  );
+  x.value = i;
+  const Pe = s(
+    () => i.items.value.map((e) => V(String(e.value)))
+  ), Ce = s(() => {
+    const e = [_.value.roots];
+    for (let a = 0; a < y.value.length; a++) {
+      const l = i.tree.index.value.map.get(
+        c(y.value.slice(0, a + 1))
+      );
+      if (!(l != null && l.hasChildren)) break;
+      e.push(
+        l.children.map((n) => i.tree.index.value.map.get(n).node)
+      );
+    }
+    return e;
+  });
+  async function ue(e) {
+    if (g.value || !f.value) return !1;
+    const a = m, l = ++J;
+    for (let n = 0; n < e.length; n++) {
+      const r = c(e.slice(0, n + 1)), u = i.tree.index.value.map.get(r);
+      if (!u || u.disabled) return !1;
+      const d = e.slice(0, n + 1).map((o, b) => c(e.slice(0, b + 1)));
+      if (await i.tree.setExpandedKeys(d), !w.value || a !== m || l !== J || !f.value || !i.tree.expanded.value.has(r) || u.hasChildren && t.loadChildren && (!await i.tree.load(r) || a !== m || l !== J || !f.value || !w.value))
+        return !1;
+    }
+    return e.length ? c(y.value) === c(e) : (await i.tree.setExpandedKeys([]), a === m && l === J && y.value.length === 0);
+  }
+  async function ke(e, a) {
+    let l = [e], n = /* @__PURE__ */ new Set();
+    for (; l.length; ) {
+      const r = l.splice(0, 4).filter((d) => !n.has(d));
+      for (const d of r) n.add(d);
+      if ((await Promise.all(
+        r.map(async (d) => {
+          let o = i.tree.index.value.map.get(d);
+          if (!o || o.disabled) return !0;
+          if (o.hasChildren && !o.children.length && !t.loadChildren)
+            return !1;
+          if (o.hasChildren && !o.children.length && t.loadChildren) {
+            if (!await i.tree.load(d)) return !1;
+            o = i.tree.index.value.map.get(d);
+          }
+          return o && l.push(...o.children.map(String)), !0;
+        })
+      )).some((d) => !d) || !f.value || !w.value || a !== m)
+        return !1;
+    }
+    return !0;
+  }
+  async function Ae(e, a, l) {
+    let n = i.tree.index.value.map.get(e);
+    if (!n || n.disabled || g.value || S.value) return !1;
+    const r = m;
+    if (v.value) {
+      if (!t.checkStrictly && n.hasChildren && !i.tree.checked.value.has(e)) {
+        S.value = !0;
+        try {
+          if (!await ke(e, r)) return !1;
+        } finally {
+          S.value = !1;
+        }
+        if (n = i.tree.index.value.map.get(e), !n) return !1;
+      }
+      return l !== void 0 && l === i.tree.checked.value.has(e) ? !1 : i.pick(n, a);
+    }
+    if (n.hasChildren && !H.value)
+      return await ue(n.node.path), !1;
+    const u = await i.request([e], "select", n.node, a);
+    return u && h("select", [...n.node.path], [...n.node.nodes], a), u;
+  }
+  function Ee(e) {
+    const a = Array.isArray(e) ? e : ne(e);
+    return i.removeTag(c(a));
+  }
+  function Ve(e) {
+    const a = re(e);
+    return i.setValue(
+      v.value ? a.map(c) : a[0] ? c(a[0]) : ""
+    );
+  }
+  const O = R(!1), X = A(), B = R("");
+  let P, Q, M = 0;
+  function Y() {
+    M++, clearTimeout(Q), Q = void 0, P == null || P.abort(), P = void 0, O.value = !1;
+  }
+  async function de(e = !1) {
+    Y(), X.value = void 0;
+    const a = i.query.value.trim();
+    if (!t.filterable || !a || !f.value || g.value) {
+      B.value = "";
+      return;
+    }
+    const l = M, n = new AbortController();
+    P = n, O.value = !0;
+    const r = async () => {
+      var d;
+      Q = void 0;
+      try {
+        const o = await (((d = t.beforeFilter) == null ? void 0 : d.call(t, a, {
+          signal: n.signal
+        })) ?? !0);
+        !n.signal.aborted && w.value && f.value && l === M && (B.value = o ? a : "");
+      } catch (o) {
+        !n.signal.aborted && l === M && (X.value = o, B.value = "", h("search-error", o, a));
+      } finally {
+        l === M && (O.value = !1, P = void 0);
+      }
+    }, u = e ? 0 : Math.max(0, Math.min(5e3, t.debounce ?? 0));
+    u ? Q = setTimeout(r, u) : await r();
+  }
+  const Me = s(() => {
+    const e = B.value;
+    if (!e) return [];
+    const a = i.tree.index.value.rows.filter((n) => !n.disabled && (H.value || !n.hasChildren)).filter(
+      (n) => t.filterMethod ? t.filterMethod(e, n.node.nodes) : n.node.labels.join(t.separator ?? " / ").toLocaleLowerCase().includes(e.toLocaleLowerCase())
+    );
+    t.searchSort && a.sort(
+      (n, r) => t.searchSort(V(String(n.key)), V(String(r.key)), e)
+    );
+    const l = t.searchLimit === !1 ? 1 / 0 : Math.max(0, Math.floor(t.searchLimit ?? 50));
+    return a.slice(0, l).map((n) => n.node);
+  });
+  z(
+    [
+      i.query,
+      f,
+      g,
+      () => t.filterable,
+      () => t.beforeFilter
+    ],
+    () => {
+      de();
+    },
+    { immediate: !0 }
+  );
+  let C, T = 0, k;
+  function U() {
+    T++, C == null || C.abort(), C = void 0, q.value = !1, k = void 0;
+  }
+  function se(e = !0) {
+    if (!t.loadRoot || !f.value || g.value)
+      return Promise.resolve(!1);
+    if (!e && N.value !== void 0) return Promise.resolve(!0);
+    if (k && !e) return k;
+    U();
+    const a = T, l = new AbortController(), n = t.loadRoot;
+    C = l, q.value = !0, D.value = void 0;
+    let r;
+    const u = new Promise((o) => {
+      r = () => o(!1), l.signal.addEventListener("abort", r, { once: !0 });
+    }), d = (async () => {
+      try {
+        const o = await n({ signal: l.signal });
+        if (l.signal.aborted || a !== T || !w.value || !f.value || n !== t.loadRoot)
+          return !1;
+        if (!Array.isArray(o))
+          throw new TypeError("loadRoot must resolve to an array");
+        return N.value = o, h("root-load", o), !0;
+      } catch (o) {
+        return !l.signal.aborted && a === T && (D.value = o, h("root-load-error", o)), !1;
+      } finally {
+        l.signal.removeEventListener("abort", r), a === T && (q.value = !1, C = void 0, k = void 0);
+      }
+    })();
+    return k = Promise.race([d, u]), k;
+  }
+  z(
+    [f, g, () => t.options, () => t.loadRoot],
+    () => {
+      f.value && !g.value && !t.options.length && t.loadRoot && se(!1);
+    },
+    { immediate: !0 }
+  ), z(
+    [() => t.options, () => t.loadRoot],
+    ([e, a], [l, n]) => {
+      !e.length && !l.length && a === n || (U(), N.value = void 0, D.value = void 0);
+    },
+    { flush: "sync" }
+  ), z(
+    [f, g],
+    () => {
+      (!f.value || g.value) && (m++, S.value = !1, U(), Y());
+    },
+    { flush: "sync" }
+  );
+  function ce() {
+    w.value = !1, m++, U(), Y(), S.value = !1;
+  }
+  return Te(ce), Le(ce), Re(() => w.value = !0), {
+    engine: i,
+    entries: F,
+    current: ae,
+    multiple: v,
+    items: Pe,
+    columns: Ce,
+    browsing: y,
+    anyLevel: H,
+    blocked: g,
+    words: me,
+    checking: S,
+    selectedPaths: oe,
+    modelKeys: j,
+    rootPending: q,
+    rootError: D,
+    filterPending: O,
+    filterError: X,
+    searchResults: Me,
+    item: V,
+    pick: Ae,
+    expandPath: ue,
+    removeTag: Ee,
+    setValue: Ve,
+    clear: i.clear,
+    filter: i.filter,
+    reloadRoot: se,
+    retrySearch: () => de(!0),
+    reloadNode: (e) => i.tree.reloadNode(c(e)),
+    getCheckedNodes: (e = !1) => v.value ? i.tree.getCheckedNodes(e).map((a) => a.raw) : j.value.flatMap((a) => {
+      const l = i.tree.index.value.map.get(a);
+      return l && (!e || !l.hasChildren) ? [l.node.raw] : [];
+    })
+  };
+}
+export {
+  Je as useCascader
+};