tuikit-atomicx-vue3 3.3.4 → 3.4.1

package/dist/components/UserPicker/hooks/useSearchFilter.js

@@ -1,91 +1,50 @@
-import { ref, computed } from "vue";
-function isTreeDataSource(data) {
-  if (data.length === 0) {
-    return false;
-  }
-  return "isLeafNode" in data[0];
+import { ref as f, computed as h } from "vue";
+function d(e) {
+  return e.length === 0 ? !1 : "isLeafNode" in e[0];
 }
-function searchTreeNodes(nodes, searchValue) {
-  if (!searchValue.trim()) {
-    return nodes;
-  }
-  const isNodeMatched = (node) => node.label.toLowerCase().includes(searchValue.toLowerCase());
-  const searchNodes = (nodesList) => {
-    const matchedNodes = [];
-    nodesList.forEach((node) => {
-      const isMatched = isNodeMatched(node);
-      let matchedChildren = [];
-      if (node.children && node.children.length) {
-        matchedChildren = searchNodes(node.children);
-      }
-      if (isMatched || matchedChildren.length > 0) {
-        matchedNodes.push({
-          ...node,
-          children: matchedChildren.length > 0 ? matchedChildren : node.children
-        });
-      }
-    });
-    return matchedNodes;
+function m(e, i) {
+  if (!i.trim())
+    return e;
+  const l = (r) => r.label.toLowerCase().includes(i.toLowerCase()), u = (r) => {
+    const n = [];
+    return r.forEach((t) => {
+      const c = l(t);
+      let s = [];
+      t.children && t.children.length && (s = u(t.children)), (c || s.length > 0) && n.push({
+        ...t,
+        children: s.length > 0 ? s : t.children
+      });
+    }), n;
   };
-  return searchNodes(nodes);
+  return u(e);
 }
-function searchListItems(items, searchValue) {
-  if (!searchValue.trim()) {
-    return items;
-  }
-  return items.filter((item) => item.label.toLowerCase().includes(searchValue.toLowerCase()));
+function g(e, i) {
+  return i.trim() ? e.filter((l) => l.label.toLowerCase().includes(i.toLowerCase())) : e;
 }
-function useSearchFilter({
-  dataSource,
-  isTreeMode = false,
-  onSearch,
+function p({
+  dataSource: e,
+  isTreeMode: i = !1,
+  onSearch: l,
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  debounceTime = 300
+  debounceTime: u = 300
 }) {
-  const searchValue = ref("");
-  const isSearching = ref(false);
-  const filteredData = computed(() => {
-    if (!searchValue.value.trim()) {
-      return dataSource.value;
-    }
-    if (isTreeMode && isTreeDataSource(dataSource.value)) {
-      return searchTreeNodes(dataSource.value, searchValue.value);
-    }
-    return searchListItems(dataSource.value, searchValue.value);
-  });
-  const handleSearch = (value) => {
-    isSearching.value = true;
-    searchValue.value = value;
-    if (onSearch) {
-      onSearch(value);
-    }
-    isSearching.value = false;
-  };
-  const clearSearch = () => {
-    searchValue.value = "";
-    if (onSearch) {
-      onSearch("");
-    }
-  };
-  const setSearchValue = (value) => {
-    searchValue.value = value;
-  };
-  const isSearchEmpty = computed(() => {
-    if (!searchValue.value.trim()) {
-      return false;
-    }
-    return Array.isArray(filteredData.value) && filteredData.value.length === 0;
-  });
+  const r = f(""), n = f(!1), t = h(() => r.value.trim() ? i && d(e.value) ? m(e.value, r.value) : g(e.value, r.value) : e.value), c = (a) => {
+    n.value = !0, r.value = a, l && l(a), n.value = !1;
+  }, s = () => {
+    r.value = "", l && l("");
+  }, o = (a) => {
+    r.value = a;
+  }, v = h(() => r.value.trim() ? Array.isArray(t.value) && t.value.length === 0 : !1);
   return {
-    searchValue,
-    setSearchValue,
-    filteredData,
-    isSearching,
-    handleSearch,
-    clearSearch,
-    isSearchEmpty
+    searchValue: r,
+    setSearchValue: o,
+    filteredData: t,
+    isSearching: n,
+    handleSearch: c,
+    clearSearch: s,
+    isSearchEmpty: v
   };
 }
 export {
-  useSearchFilter
+  p as useSearchFilter
 };

package/dist/components/UserPicker/hooks/useSelection.js

@@ -1,351 +1,193 @@
-import { ref, computed, watch } from "vue";
-function isTreeDataSource(data) {
-  if (data.length === 0) {
-    return false;
-  }
-  return "isLeafNode" in data[0];
+import { ref as A, computed as w, watch as G } from "vue";
+function m(d) {
+  return d.length === 0 ? !1 : "isLeafNode" in d[0];
 }
-function buildAllNodesMap(nodes) {
-  const map = /* @__PURE__ */ new Map();
-  const traverse = (nodesToScan) => {
-    nodesToScan.forEach((node) => {
-      map.set(node.key, node);
-      if (node.children && node.children.length) {
-        traverse(node.children);
-      }
+function J(d) {
+  const o = /* @__PURE__ */ new Map(), h = (g) => {
+    g.forEach((r) => {
+      o.set(r.key, r), r.children && r.children.length && h(r.children);
     });
   };
-  traverse(nodes);
-  return map;
+  return h(d), o;
 }
-function buildParentChildrenMap(nodes) {
-  const map = /* @__PURE__ */ new Map();
-  const traverse = (nodesList, parentKey) => {
-    nodesList.forEach((node) => {
-      var _a;
-      if (parentKey) {
-        if (!map.has(parentKey)) {
-          map.set(parentKey, []);
-        }
-        (_a = map.get(parentKey)) == null ? void 0 : _a.push(node.key);
-      }
-      if (node.children && node.children.length) {
-        traverse(node.children, node.key);
-      }
+function O(d) {
+  const o = /* @__PURE__ */ new Map(), h = (g, r) => {
+    g.forEach((c) => {
+      var b;
+      r && (o.has(r) || o.set(r, []), (b = o.get(r)) == null || b.push(c.key)), c.children && c.children.length && h(c.children, c.key);
     });
   };
-  traverse(nodes);
-  return map;
+  return h(d), o;
 }
-function buildChildParentMap(nodes) {
-  const map = /* @__PURE__ */ new Map();
-  const traverse = (nodesList, parentKey) => {
-    nodesList.forEach((node) => {
-      if (parentKey) {
-        map.set(node.key, parentKey);
-      }
-      if (node.children && node.children.length) {
-        traverse(node.children, node.key);
-      }
+function Q(d) {
+  const o = /* @__PURE__ */ new Map(), h = (g, r) => {
+    g.forEach((c) => {
+      r && o.set(c.key, r), c.children && c.children.length && h(c.children, c.key);
     });
   };
-  traverse(nodes);
-  return map;
+  return h(d), o;
 }
-function areSetsEqual(a, b) {
-  if (a.size !== b.size) {
-    return false;
-  }
-  return Array.from(a).every((item) => b.has(item));
+function q(d, o) {
+  return d.size !== o.size ? !1 : Array.from(d).every((h) => o.has(h));
 }
-function useSelection({
-  defaultSelectedKeys = [],
-  lockedKeys = [],
-  maxCount = Infinity,
-  minCount = 0,
-  isTreeMode = false,
-  dataSource,
-  onSelectedChange,
-  onMaxCountExceed
+function V({
+  defaultSelectedKeys: d = [],
+  lockedKeys: o = [],
+  maxCount: h = 1 / 0,
+  minCount: g = 0,
+  isTreeMode: r = !1,
+  dataSource: c,
+  onSelectedChange: b,
+  onMaxCountExceed: D
 }) {
-  const selectedKeys = ref(new Set(defaultSelectedKeys));
-  const halfSelectedKeys = ref(/* @__PURE__ */ new Set());
-  const lockedKeysSet = ref(new Set(lockedKeys));
-  const parentChildrenMap = computed(() => {
-    if (isTreeMode && isTreeDataSource(dataSource.value)) {
-      return buildParentChildrenMap(dataSource.value);
-    }
-    return /* @__PURE__ */ new Map();
-  });
-  const childParentMap = computed(() => {
-    if (isTreeMode && isTreeDataSource(dataSource.value)) {
-      return buildChildParentMap(dataSource.value);
-    }
-    return /* @__PURE__ */ new Map();
-  });
-  const nodeEntitiesMap = computed(() => {
-    if (isTreeMode && isTreeDataSource(dataSource.value)) {
-      return buildAllNodesMap(dataSource.value);
-    }
-    return /* @__PURE__ */ new Map();
-  });
-  const allSelectedCount = computed(() => selectedKeys.value.size);
-  const canSelectMore = computed(() => allSelectedCount.value < maxCount);
-  const reachMaxCount = computed(() => allSelectedCount.value >= maxCount);
-  const getNodeChildKeys = (node) => {
-    const result = [];
-    const traverse = (nodeKey) => {
-      const childKeys = parentChildrenMap.value.get(nodeKey);
-      if (childKeys) {
-        childKeys.forEach((childKey) => {
-          result.push(childKey);
-          traverse(childKey);
-        });
-      }
+  const u = A(new Set(d)), N = A(/* @__PURE__ */ new Set()), L = A(new Set(o)), S = w(() => r && m(c.value) ? O(c.value) : /* @__PURE__ */ new Map()), I = w(() => r && m(c.value) ? Q(c.value) : /* @__PURE__ */ new Map()), E = w(() => r && m(c.value) ? J(c.value) : /* @__PURE__ */ new Map()), P = w(() => u.value.size), F = w(() => P.value < h), K = w(() => P.value >= h), M = (t) => {
+    const l = [], f = (s) => {
+      const e = S.value.get(s);
+      e && e.forEach((a) => {
+        l.push(a), f(a);
+      });
     };
-    traverse(node.key);
-    return result;
-  };
-  const getSelectableLeafNodes = (nodeKey) => {
-    const nodeEntity = nodeEntitiesMap.value.get(nodeKey);
-    if ((nodeEntity == null ? void 0 : nodeEntity.isLeafNode) && !selectedKeys.value.has(nodeKey) && !lockedKeysSet.value.has(nodeKey)) {
-      return [nodeEntity];
-    }
-    const childKeys = getNodeChildKeys({ key: nodeKey });
-    const selectableLeafNodes = childKeys.filter((key) => !selectedKeys.value.has(key) && !lockedKeysSet.value.has(key)).map((key) => nodeEntitiesMap.value.get(key)).filter((childNode) => childNode == null ? void 0 : childNode.isLeafNode);
-    return selectableLeafNodes;
-  };
-  const getCancelableLeafNodes = (nodeKey) => {
-    const nodeEntity = nodeEntitiesMap.value.get(nodeKey);
-    if ((nodeEntity == null ? void 0 : nodeEntity.isLeafNode) && selectedKeys.value.has(nodeKey)) {
-      return [nodeEntity];
+    return f(t.key), l;
+  }, y = (t) => {
+    const l = E.value.get(t);
+    return l != null && l.isLeafNode && !u.value.has(t) && !L.value.has(t) ? [l] : M({ key: t }).filter((e) => !u.value.has(e) && !L.value.has(e)).map((e) => E.value.get(e)).filter((e) => e == null ? void 0 : e.isLeafNode);
+  }, z = (t) => {
+    const l = E.value.get(t);
+    return l != null && l.isLeafNode && u.value.has(t) ? [l] : M({ key: t }).filter((e) => u.value.has(e) && !L.value.has(e)).map((e) => E.value.get(e)).filter((e) => e == null ? void 0 : e.isLeafNode);
+  }, _ = (t) => {
+    const l = [t];
+    let f = t;
+    for (; I.value.has(f); ) {
+      const s = I.value.get(f);
+      l.push(s), f = s;
     }
-    const childKeys = getNodeChildKeys({ key: nodeKey });
-    const cancelableLeafNodes = childKeys.filter((key) => selectedKeys.value.has(key) && !lockedKeysSet.value.has(key)).map((key) => nodeEntitiesMap.value.get(key)).filter((childNode) => childNode == null ? void 0 : childNode.isLeafNode);
-    return cancelableLeafNodes;
-  };
-  const getNodeParentKeyPath = (key) => {
-    const path = [key];
-    let current = key;
-    while (childParentMap.value.has(current)) {
-      const parentKey = childParentMap.value.get(current);
-      path.push(parentKey);
-      current = parentKey;
-    }
-    return path;
-  };
-  const updateSelectedStates = () => {
-    if (!isTreeMode) {
+    return l;
+  }, j = () => {
+    if (!r)
       return;
-    }
-    const newSelectedKeys = /* @__PURE__ */ new Set();
-    const newHalfSelectedKeys = /* @__PURE__ */ new Set();
-    const allNodes = new Set(Array.from(selectedKeys.value));
-    parentChildrenMap.value.forEach((_, parentKey) => {
-      allNodes.add(parentKey);
-    });
-    parentChildrenMap.value.forEach((childKeys) => {
-      childKeys.forEach((childKey) => allNodes.add(childKey));
-    });
-    selectedKeys.value.forEach((key) => {
-      const childKeys = parentChildrenMap.value.get(key);
-      if (!childKeys || childKeys.length === 0) {
-        if (selectedKeys.value.has(key)) {
-          newSelectedKeys.add(key);
-        }
-      }
+    const t = /* @__PURE__ */ new Set(), l = /* @__PURE__ */ new Set(), f = new Set(Array.from(u.value));
+    S.value.forEach((a, n) => {
+      f.add(n);
+    }), S.value.forEach((a) => {
+      a.forEach((n) => f.add(n));
+    }), u.value.forEach((a) => {
+      const n = S.value.get(a);
+      (!n || n.length === 0) && u.value.has(a) && t.add(a);
     });
-    let stateChanged = true;
-    const updateParentState = (nodeKey) => {
-      if (lockedKeysSet.value.has(nodeKey)) {
+    let s = !0;
+    const e = (a) => {
+      if (L.value.has(a))
         return;
-      }
-      const childKeys = parentChildrenMap.value.get(nodeKey);
-      if (!childKeys || childKeys.length === 0) {
+      const n = S.value.get(a);
+      if (!n || n.length === 0)
         return;
-      }
-      const unlockedChildKeys = childKeys.filter((key) => !lockedKeysSet.value.has(key));
-      if (unlockedChildKeys.length === 0) {
+      const i = n.filter((C) => !L.value.has(C));
+      if (i.length === 0)
         return;
-      }
-      const selectedChildCount = unlockedChildKeys.filter((key) => newSelectedKeys.has(key)).length;
-      const halfSelectedChildCount = unlockedChildKeys.filter((key) => newHalfSelectedKeys.has(key)).length;
-      const wasSelected = newSelectedKeys.has(nodeKey);
-      const wasHalfSelected = newHalfSelectedKeys.has(nodeKey);
-      if (selectedChildCount === unlockedChildKeys.length) {
-        if (!wasSelected || wasHalfSelected) {
-          newSelectedKeys.add(nodeKey);
-          newHalfSelectedKeys.delete(nodeKey);
-          stateChanged = true;
-        }
-      } else if (selectedChildCount > 0 || halfSelectedChildCount > 0) {
-        if (wasSelected || !wasHalfSelected) {
-          newSelectedKeys.delete(nodeKey);
-          newHalfSelectedKeys.add(nodeKey);
-          stateChanged = true;
-        }
-      } else if (wasSelected || wasHalfSelected) {
-        newSelectedKeys.delete(nodeKey);
-        newHalfSelectedKeys.delete(nodeKey);
-        stateChanged = true;
-      }
+      const v = i.filter((C) => t.has(C)).length, k = i.filter((C) => l.has(C)).length, H = t.has(a), U = l.has(a);
+      v === i.length ? (!H || U) && (t.add(a), l.delete(a), s = !0) : v > 0 || k > 0 ? (H || !U) && (t.delete(a), l.add(a), s = !0) : (H || U) && (t.delete(a), l.delete(a), s = !0);
     };
-    while (stateChanged) {
-      stateChanged = false;
-      allNodes.forEach(updateParentState);
-    }
-    if (!areSetsEqual(newSelectedKeys, selectedKeys.value)) {
-      selectedKeys.value = newSelectedKeys;
-    }
-    if (!areSetsEqual(newHalfSelectedKeys, halfSelectedKeys.value)) {
-      halfSelectedKeys.value = newHalfSelectedKeys;
-    }
-  };
-  const toggle = (key) => {
-    if (lockedKeysSet.value.has(key)) {
+    for (; s; )
+      s = !1, f.forEach(e);
+    q(t, u.value) || (u.value = t), q(l, N.value) || (N.value = l);
+  }, B = (t) => {
+    if (L.value.has(t))
       return;
-    }
-    const newSelectedKeys = new Set(selectedKeys.value);
-    if (isTreeMode) {
-      const isFullySelected = newSelectedKeys.has(key);
-      const isHalfSelected = halfSelectedKeys.value.has(key);
-      if (isFullySelected) {
-        const cancelableLeafNodes = getCancelableLeafNodes(key);
-        const selectedLeafNodes = getSelectedItems().filter((item) => item.isLeafNode);
-        const currentSelectedKeyCount = selectedLeafNodes.length;
-        if (cancelableLeafNodes.length > 0) {
-          if (currentSelectedKeyCount - cancelableLeafNodes.length >= minCount) {
-            cancelableLeafNodes.forEach((node) => {
-              newSelectedKeys.delete(node.key);
-            });
-          }
-        }
-      } else if (isHalfSelected) {
-        const selectableChildLeafCount = getSelectableLeafNodes(key).length;
-        if (selectableChildLeafCount === 0) {
-          const cancelableLeafNodes = getCancelableLeafNodes(key);
-          const selectedLeafNodes = getSelectedItems().filter((item) => item.isLeafNode);
-          const currentSelectedKeyCount = selectedLeafNodes.length;
-          if (cancelableLeafNodes.length > 0) {
-            if (currentSelectedKeyCount - cancelableLeafNodes.length >= minCount) {
-              cancelableLeafNodes.forEach((node) => {
-                newSelectedKeys.delete(node.key);
-              });
-            }
-          }
-        } else if (selectableChildLeafCount > 0) {
-          const selectedLeafNodes = getSelectedItems().filter((item) => item.isLeafNode);
-          if (selectedLeafNodes.length + selectableChildLeafCount <= maxCount) {
-            const selectableLeafNodes = getSelectableLeafNodes(key);
-            selectableLeafNodes.forEach((node) => {
-              newSelectedKeys.add(node.key);
-            });
-          }
-        }
-      } else {
-        const selectableLeafNodes = getSelectableLeafNodes(key);
-        if (selectableLeafNodes.length > 0) {
-          const selectedLeafNodes = getSelectedItems().filter((item) => item.isLeafNode);
-          if (selectedLeafNodes.length + selectableLeafNodes.length <= maxCount) {
-            selectableLeafNodes.forEach((node) => {
-              newSelectedKeys.add(node.key);
-            });
-          }
-        }
-      }
-    } else {
-      const isCurrentlySelected = newSelectedKeys.has(key);
-      if (isCurrentlySelected) {
-        newSelectedKeys.delete(key);
-      } else if (newSelectedKeys.size < maxCount) {
-        newSelectedKeys.add(key);
+    const l = new Set(u.value);
+    if (r) {
+      const f = l.has(t), s = N.value.has(t);
+      if (f) {
+        const e = z(t), n = p().filter((i) => i.isLeafNode).length;
+        e.length > 0 && n - e.length >= g && e.forEach((i) => {
+          l.delete(i.key);
+        });
+      } else if (s) {
+        const e = y(t).length;
+        if (e === 0) {
+          const a = z(t), i = p().filter((v) => v.isLeafNode).length;
+          a.length > 0 && i - a.length >= g && a.forEach((v) => {
+            l.delete(v.key);
+          });
+        } else e > 0 && p().filter((n) => n.isLeafNode).length + e <= h && y(t).forEach((i) => {
+          l.add(i.key);
+        });
       } else {
-        onMaxCountExceed == null ? void 0 : onMaxCountExceed(getSelectedItems());
+        const e = y(t);
+        e.length > 0 && p().filter((n) => n.isLeafNode).length + e.length <= h && e.forEach((n) => {
+          l.add(n.key);
+        });
       }
-    }
-    selectedKeys.value = newSelectedKeys;
-  };
-  const getSelectedItems = () => {
-    const result = [];
-    if (isTreeMode && isTreeDataSource(dataSource.value)) {
-      const treeData = dataSource.value;
-      const findNode = (key, nodes) => {
-        var _a;
-        const found = nodes.find((node) => node.key === key);
-        if (found) {
-          return found;
-        }
-        for (let i = 0; i < nodes.length; i += 1) {
-          const node = nodes[i];
-          if ((_a = node.children) == null ? void 0 : _a.length) {
-            const foundInChildren = findNode(key, node.children);
-            if (foundInChildren) {
-              return foundInChildren;
-            }
+    } else
+      l.has(t) ? l.delete(t) : l.size < h ? l.add(t) : D == null || D(p());
+    u.value = l;
+  }, p = () => {
+    const t = [];
+    if (r && m(c.value)) {
+      const l = c.value, f = (s, e) => {
+        var n;
+        const a = e.find((i) => i.key === s);
+        if (a)
+          return a;
+        for (let i = 0; i < e.length; i += 1) {
+          const v = e[i];
+          if ((n = v.children) != null && n.length) {
+            const k = f(s, v.children);
+            if (k)
+              return k;
           }
         }
         return null;
       };
-      selectedKeys.value.forEach((key) => {
-        const node = findNode(key, treeData);
-        if (node) {
-          result.push({
-            key: node.key,
-            label: node.label,
-            avatarUrl: node.avatarUrl,
-            isLeafNode: node.isLeafNode,
-            extraData: node.extraData,
-            // Calculate node path
-            path: [...getNodeParentKeyPath(node.key)].reverse()
-          });
-        }
+      u.value.forEach((s) => {
+        const e = f(s, l);
+        e && t.push({
+          key: e.key,
+          label: e.label,
+          avatarUrl: e.avatarUrl,
+          isLeafNode: e.isLeafNode,
+          extraData: e.extraData,
+          // Calculate node path
+          path: [..._(e.key)].reverse()
+        });
       });
     } else {
-      const listData = dataSource.value;
-      selectedKeys.value.forEach((key) => {
-        const item = listData.find((listItem) => listItem.key === key);
-        if (item) {
-          result.push({
-            key: item.key,
-            label: item.label,
-            avatarUrl: item.avatarUrl,
-            extraData: item.extraData
-          });
-        }
+      const l = c.value;
+      u.value.forEach((f) => {
+        const s = l.find((e) => e.key === f);
+        s && t.push({
+          key: s.key,
+          label: s.label,
+          avatarUrl: s.avatarUrl,
+          extraData: s.extraData
+        });
       });
     }
-    return result;
+    return t;
   };
-  watch(
-    [selectedKeys, halfSelectedKeys],
+  return G(
+    [u, N],
     () => {
-      if (isTreeMode) {
-        updateSelectedStates();
-      }
-      if (onSelectedChange) {
-        onSelectedChange(getSelectedItems());
-      }
+      r && j(), b && b(p());
     },
-    { deep: true }
-  );
-  return {
-    selectedKeys,
-    halfSelectedKeys,
-    lockedKeys: lockedKeysSet,
-    isSelected: (key) => selectedKeys.value.has(key),
-    isHalfSelected: (key) => halfSelectedKeys.value.has(key),
-    isLocked: (key) => lockedKeysSet.value.has(key),
-    toggle,
-    getSelectedItems,
-    getNodeChildKeys,
-    getSelectableLeafNodes,
-    getCancelableLeafNodes,
-    getNodeParentChildrenMap: () => parentChildrenMap.value,
-    canSelectMore,
-    reachMaxCount,
-    allSelectedCount
+    { deep: !0 }
+  ), {
+    selectedKeys: u,
+    halfSelectedKeys: N,
+    lockedKeys: L,
+    isSelected: (t) => u.value.has(t),
+    isHalfSelected: (t) => N.value.has(t),
+    isLocked: (t) => L.value.has(t),
+    toggle: B,
+    getSelectedItems: p,
+    getNodeChildKeys: M,
+    getSelectableLeafNodes: y,
+    getCancelableLeafNodes: z,
+    getNodeParentChildrenMap: () => S.value,
+    canSelectMore: F,
+    reachMaxCount: K,
+    allSelectedCount: P
   };
 }
 export {
-  useSelection
+  V as useSelection
 };