@rio-cloud/rio-uikit 2.0.0-beta.1 → 2.0.0

package/components/assetTree/Tree.js

@@ -1,297 +1,337 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-/* eslint-disable no-use-before-define */
-import React, { useCallback, useEffect, useReducer, useRef } from 'react';
-import classNames from 'classnames';
-import { cond, filter, isEmpty, noop, omit, size, stubTrue as otherwise, flow, map, find, without, } from 'es-toolkit/compat';
-import { isEqual, isNil } from 'es-toolkit/predicate';
-import TreeSearch from "./TreeSearch.js";
-import TreeSelectAll from "./TreeSelectAll.js";
-import TreeSummary from "./TreeSummary.js";
-import TreeNodeContainer from "./TreeNodeContainer.js";
-import TreeNode from "./TreeNode.js";
-import TreeLeafList from "./TreeLeafList.js";
-import TreeNothingFound from "./TreeNothingFound.js";
-import TreeOptions from "./TreeOptions.js";
-import TreeRoot from "./TreeRoot.js";
-import TypeCounter from "./TypeCounter.js";
-import { containsItemById, debounceFn, filterAssetByType, filterEmptyGroups, filterOutByItemId, getTypeCounts, getFlatItems, getListIds, notEmpty, notEqual, excludeFromList, getMappedItemsToGroups, sortGroupItemsByName, sortGroupsByName, addOrRemoveFromList, } from "./treeUtils.js";
-import { treeReducer, assetCounted, allCheckedChanged, visibleTypeCountersChanged, searchValueChanged, flatItemsChanged, emptyGroupsChanged, groupedItemsChanged, typeFilterChanged, } from "./treeReducer.js";
-import { useTreeVirtualization } from "./useTreeVirtualization.js";
-import { useTreeExpansion } from "./useTreeExpansion.js";
-import { useTreeHeight } from "./useTreeHeight.js";
-import { useTreeScrollPosition } from "./useTreeScrollPosition.js";
-import SmoothScrollbars from "../../SmoothScrollbars.js";
-export { getTypeCounts, getSubTypeCounts } from "./treeUtils.js";
-const filterProps = (props) => omit(props, ['expandedGroups', 'onExpandGroupsChange', 'onSearchChange', 'onSelectionChange', 'treeOptions']);
-const customCompare = (prevProps, nextProps) => isEqual(filterProps(prevProps), filterProps(nextProps));
-const VIRTUALIZED_THRESHOLD = 50;
-const DEFAULT_VIRTUALIZED_OVERSCAN = 5;
-const Tree = React.memo((props) => {
-    const { groups = [], items = [], selectedGroups = [], selectedItems = [], onSelectionChange = noop, hasMultiselect = true, showRadioButtons = false, hideSearch = false, hideTreeHead, treeHeaderContent, summary, hideSummary = false, search, searchPlaceholder = 'Type here to filter by name', onSearchChange = noop, className, scrollHeight, expandedGroups, onExpandGroupsChange = noop, showEmptyGroups = true, treeOptions = [], treeOptionsTooltip, disableAnimation = false, onTypeFilterChange = noop, virtualizeThreshold = VIRTUALIZED_THRESHOLD, overscan = DEFAULT_VIRTUALIZED_OVERSCAN, ...remainingProps } = props;
-    const [state, dispatch] = useReducer(treeReducer, {
-        groupedItems: {},
-        flatItems: [],
-        allChecked: false,
-        searchValue: '',
-        assetCounts: {},
-        typeFilter: [],
-        visibleTypeCounters: [],
-        emptyGroups: [],
+import { jsxs as R, jsx as n } from "react/jsx-runtime";
+import pt, { useReducer as mt, useRef as E, useCallback as pe, useEffect as F } from "react";
+import me from "classnames";
+import { noop as k, size as y, isEmpty as u, filter as H, cond as q, stubTrue as Z, map as Y, flow as ht, omit as ft, find as gt, without as St } from "es-toolkit/compat";
+import { isNil as It, isEqual as W } from "es-toolkit/predicate";
+import Tt from "./TreeSearch.js";
+import yt from "./TreeSelectAll.js";
+import Gt from "./TreeSummary.js";
+import w from "./TreeNodeContainer.js";
+import he from "./TreeNode.js";
+import J from "./TreeLeafList.js";
+import fe from "./TreeNothingFound.js";
+import Ct from "./TreeOptions.js";
+import At from "./TreeRoot.js";
+import xt from "./TypeCounter.js";
+import { notEmpty as S, notEqual as K, getTypeCounts as ge, debounceFn as Nt, filterOutByItemId as Q, filterAssetByType as Et, getMappedItemsToGroups as Ft, sortGroupsByName as vt, sortGroupItemsByName as bt, filterEmptyGroups as Lt, getFlatItems as Ot, containsItemById as Vt, addOrRemoveFromList as Rt, excludeFromList as kt, getListIds as Se } from "./treeUtils.js";
+import { getSubTypeCounts as xs } from "./treeUtils.js";
+import { treeReducer as Ht, assetCounted as Ie, allCheckedChanged as v, visibleTypeCountersChanged as wt, emptyGroupsChanged as zt, groupedItemsChanged as $t, flatItemsChanged as Pt, searchValueChanged as Bt, typeFilterChanged as jt } from "./treeReducer.js";
+import { useTreeVirtualization as Dt } from "./useTreeVirtualization.js";
+import { useTreeExpansion as Mt } from "./useTreeExpansion.js";
+import { useTreeHeight as Ut } from "./useTreeHeight.js";
+import { useTreeScrollPosition as _t } from "./useTreeScrollPosition.js";
+import qt from "../smoothScrollbars/SmoothScrollbars.js";
+const Te = (I) => ft(I, ["expandedGroups", "onExpandGroupsChange", "onSearchChange", "onSelectionChange", "treeOptions"]), Zt = (I, c) => W(Te(I), Te(c)), Yt = 50, Jt = 5, Gs = pt.memo((I) => {
+  const {
+    groups: c = [],
+    items: m = [],
+    selectedGroups: i = [],
+    selectedItems: f = [],
+    onSelectionChange: ye = k,
+    hasMultiselect: G = !0,
+    showRadioButtons: z = !1,
+    hideSearch: Ge = !1,
+    hideTreeHead: Ce,
+    treeHeaderContent: Ae,
+    summary: xe,
+    hideSummary: Ne = !1,
+    search: X,
+    searchPlaceholder: Ee = "Type here to filter by name",
+    onSearchChange: Fe = k,
+    className: ve,
+    scrollHeight: ee,
+    expandedGroups: Kt,
+    onExpandGroupsChange: Qt = k,
+    showEmptyGroups: b = !0,
+    treeOptions: be = [],
+    treeOptionsTooltip: Le,
+    disableAnimation: x = !1,
+    onTypeFilterChange: Oe = k,
+    virtualizeThreshold: te = Yt,
+    overscan: Ve = Jt,
+    ...Re
+  } = I, [o, d] = mt(Ht, {
+    groupedItems: {},
+    flatItems: [],
+    allChecked: !1,
+    searchValue: "",
+    assetCounts: {},
+    typeFilter: [],
+    visibleTypeCounters: [],
+    emptyGroups: []
+  }), se = E(null), oe = E(), re = E(), ne = E(""), { internalExpandedGroups: le, handleToggleNode: $ } = Mt(
+    I.expandedGroups,
+    I.onExpandGroupsChange
+  ), C = () => c && S(c), T = () => S(o.searchValue), P = () => T() && C(), B = () => !T() && C(), j = E(null), { virtualizedItems: D, virtualizer: g } = Dt(
+    o.groupedItems,
+    o.flatItems,
+    T(),
+    C(),
+    le,
+    j,
+    Ve
+  ), { scrollToTop: ke } = _t(g, j), He = pe(
+    (e) => {
+      $(e);
+    },
+    [$]
+  ), we = pe(
+    (e) => {
+      if (g && e?.target) {
+        const t = e.target;
+        g.scrollToOffset(t.scrollTop, { align: "start" });
+      }
+    },
+    [g]
+  );
+  F(() => {
+    if (K(oe.current, m) || K(re.current, c)) {
+      oe.current = m, re.current = c;
+      const e = ge(m);
+      d(Ie(e));
+      const t = $e({ items: m, groups: c, selectedItems: f, selectedGroups: i }, o.flatItems);
+      d(v(t)), d(wt(Object.keys(e))), L(c, m);
+    }
+  }, [m, c]);
+  const ze = Nt(
+    (e, t) => L(e, t)
+  );
+  F(() => {
+    K(ne.current, o.searchValue) && (ze(c, m), ne.current = o.searchValue);
+  }, [o.searchValue]), F(() => L(c, m), [o.typeFilter]), F(() => L(c, m), [b]), F(() => {
+    const e = y(c), t = y(i);
+    t !== e && o.allChecked ? d(v(!1)) : t !== 0 && t === e && !o.allChecked && d(v(!0));
+  }, [i]);
+  const $e = (e, t) => {
+    const {
+      items: s,
+      groups: r,
+      selectedItems: l,
+      selectedGroups: a
+    } = e;
+    if (!C() && u(l) || B() && u(a) || P() && u(l))
+      return !1;
+    if (B()) {
+      const p = H(r, Q(a));
+      return u(p);
+    }
+    if (P()) {
+      const p = H(t, Q(l));
+      return u(p);
+    }
+    const h = s.filter(Q(l));
+    return u(h);
+  }, Pe = (e) => ce(e), Be = (e, t) => {
+    const s = e && !t;
+    d(v(s)), q([
+      [B, () => je(s)],
+      [P, () => Pe(s)],
+      [Z, () => ce(s)]
+    ])();
+  }, je = (e) => A([], e ? Se(c) : []), ce = (e) => A(e ? Se(o.flatItems) : [], []), A = (e, t) => {
+    ye({
+      items: e,
+      groups: t
     });
-    const treeRef = useRef(null);
-    const previousItems = useRef();
-    const previousGroups = useRef();
-    const previousSearchValue = useRef('');
-    const { internalExpandedGroups, handleToggleNode } = useTreeExpansion(props.expandedGroups, props.onExpandGroupsChange);
-    const hasGroups = () => groups && notEmpty(groups);
-    const hasInternalSearchValue = () => notEmpty(state.searchValue);
-    const hasSearchAndGroups = () => hasInternalSearchValue() && hasGroups();
-    const hasNoSearchAndGroups = () => !hasInternalSearchValue() && hasGroups();
-    const scrollElementRef = useRef(null);
-    const { virtualizedItems, virtualizer } = useTreeVirtualization(state.groupedItems, state.flatItems, hasInternalSearchValue(), hasGroups(), internalExpandedGroups, scrollElementRef, overscan);
-    const { scrollToTop } = useTreeScrollPosition(virtualizer, scrollElementRef);
-    // Enhance the handleToggleNode function
-    const enhancedHandleToggleNode = useCallback((nodeId) => {
-        // Execute the original toggle logic
-        handleToggleNode(nodeId);
-    }, [handleToggleNode]);
-    // Create a callback for scroll events that works with the virtualizer
-    const handleVirtualizedScroll = useCallback((event) => {
-        if (virtualizer && event?.target) {
-            const scrollElement = event.target;
-            virtualizer.scrollToOffset(scrollElement.scrollTop, { align: 'start' });
-        }
-    }, [virtualizer]);
-    useEffect(() => {
-        // Update Tree when items or groups have changed
-        if (notEqual(previousItems.current, items) || notEqual(previousGroups.current, groups)) {
-            previousItems.current = items;
-            previousGroups.current = groups;
-            const typeCounts = getTypeCounts(items);
-            dispatch(assetCounted(typeCounts));
-            const allChecked = checkAllSelected({ items, groups, selectedItems, selectedGroups }, state.flatItems);
-            dispatch(allCheckedChanged(allChecked));
-            // Get the distinct asset types from the asset list that is passed into the component
-            // to know which asset type counter to render
-            dispatch(visibleTypeCountersChanged(Object.keys(typeCounts)));
-            makeTree(groups, items);
-        }
-    }, [items, groups]);
-    const debouncedMakeTree = debounceFn((losGroupos, losItems) => makeTree(losGroupos, losItems));
-    useEffect(() => {
-        // To prevent executing the effect on first render, use a ref to check previous render values
-        if (notEqual(previousSearchValue.current, state.searchValue)) {
-            debouncedMakeTree(groups, items);
-            previousSearchValue.current = state.searchValue;
-        }
-    }, [state.searchValue]);
-    useEffect(() => makeTree(groups, items), [state.typeFilter]);
-    // Update tree when empty groups are toggled from outside
-    useEffect(() => makeTree(groups, items), [showEmptyGroups]);
-    // Update "select all" state from outside when groups are selected outside programmatically
-    // without using the "select all" checkbox
-    useEffect(() => {
-        const numOfAllGroups = size(groups);
-        const numOfSelectedGroups = size(selectedGroups);
-        if (numOfSelectedGroups !== numOfAllGroups && state.allChecked) {
-            dispatch(allCheckedChanged(false));
-        }
-        else if (numOfSelectedGroups !== 0 && numOfSelectedGroups === numOfAllGroups && !state.allChecked) {
-            dispatch(allCheckedChanged(true));
-        }
-    }, [selectedGroups]);
-    const checkAllSelected = (updatedProps, flatItems) => {
-        const { items: updatedItems, groups: updatedGroups, selectedItems: updatedSelectedItems, selectedGroups: updatedSelectedGroups, } = updatedProps;
-        if ((!hasGroups() && isEmpty(updatedSelectedItems)) ||
-            (hasNoSearchAndGroups() && isEmpty(updatedSelectedGroups)) ||
-            (hasSearchAndGroups() && isEmpty(updatedSelectedItems))) {
-            return false;
-        }
-        if (hasNoSearchAndGroups()) {
-            const unselectedGroups = filter(updatedGroups, filterOutByItemId(updatedSelectedGroups));
-            return isEmpty(unselectedGroups);
-        }
-        if (hasSearchAndGroups()) {
-            const unselectedSearchItems = filter(flatItems, filterOutByItemId(updatedSelectedItems));
-            return isEmpty(unselectedSearchItems);
-        }
-        const unselectedItems = updatedItems.filter(filterOutByItemId(updatedSelectedItems));
-        return isEmpty(unselectedItems);
-    };
-    const selectAllSearchResultItems = (shouldSelect) => selectAllFlatItems(shouldSelect);
-    const handleSelectAll = (shouldSelect, isStateIndeterminate) => {
-        const shouldSelectAll = shouldSelect && !isStateIndeterminate;
-        dispatch(allCheckedChanged(shouldSelectAll));
-        cond([
-            [hasNoSearchAndGroups, () => selectAllGroups(shouldSelectAll)],
-            [hasSearchAndGroups, () => selectAllSearchResultItems(shouldSelectAll)],
-            [otherwise, () => selectAllFlatItems(shouldSelectAll)],
-        ])();
-    };
-    const selectAllGroups = (shouldSelect) => respondSelection([], shouldSelect ? getListIds(groups) : []);
-    const selectAllFlatItems = (shouldSelect) => respondSelection(shouldSelect ? getListIds(state.flatItems) : [], []);
-    const respondSelection = (updatedSelectedItemIds, updatedSelectedGroupIds) => {
-        onSelectionChange({
-            items: updatedSelectedItemIds,
-            groups: updatedSelectedGroupIds,
-        });
-    };
-    const handleGroupSelection = (group, isStateIndeterminate) => {
-        const groupId = group.id;
-        const isSelected = selectedGroups.includes(groupId);
-        const shouldSelectGroup = !isSelected && !isStateIndeterminate;
-        // handle group selection
-        const newSelectedGroups = shouldSelectGroup
-            ? [...selectedGroups, groupId]
-            : excludeFromList(selectedGroups, groupId);
-        // deselect all items of a node since they will be selected inherently via the group itself
-        const itemsInGroup = find(state.groupedItems, (entry) => entry.id === groupId);
-        const itemIdsOfGroup = map(itemsInGroup?.items, (item) => item.id);
-        const updatedSelectedItems = without(selectedItems, ...itemIdsOfGroup);
-        // check if all groups are selected to change the state of TreeSelectAll
-        const groupAmount = groups.length;
-        const emptyGroupAmount = showEmptyGroups ? 0 : state.emptyGroups.length;
-        const totalGroupAmount = groupAmount - emptyGroupAmount;
-        const areAllGroupsChecked = totalGroupAmount === newSelectedGroups.length;
-        dispatch(allCheckedChanged(areAllGroupsChecked));
-        respondSelection(updatedSelectedItems, newSelectedGroups);
-    };
-    const handleSearchChange = (updatedSearchValue) => {
-        onSearchChange(updatedSearchValue);
-        dispatch(searchValueChanged(updatedSearchValue));
-        if (virtualizer) {
-            // Every time search changes or is cleared, scroll to the top
-            setTimeout(() => {
-                scrollToTop();
-            }, 10);
-        }
-    };
-    const setFlatItemList = (updatedItems, searchValue) => {
-        const flatItems = getFlatItems(updatedItems, searchValue);
-        dispatch(flatItemsChanged(flatItems));
-    };
-    const setGroupedItemList = (groupsToProcess, itemsToProcess, considerEmptyGroups) => {
-        // Map items to groups with filtered items
-        const mappedItemsToGroups = getMappedItemsToGroups(groupsToProcess, itemsToProcess);
-        const newGroupedItems = flow(sortGroupsByName, sortGroupItemsByName)(mappedItemsToGroups);
-        const groupedItems = considerEmptyGroups ? newGroupedItems : filterEmptyGroups(newGroupedItems);
-        // Keep the empty groups in memory for later access in select all, without re-iterating on every
-        // group selection
-        const emptyGroups = filter(newGroupedItems, (group) => isEmpty(group.items));
-        dispatch(emptyGroupsChanged(emptyGroups));
-        dispatch(assetCounted(getTypeCounts(items)));
-        dispatch(groupedItemsChanged(groupedItems));
-        // Update expanded groups again
-    };
-    const makeTree = (updatedGroups, updatedItems) => {
-        const internalSearchValue = state.searchValue;
-        const internalTypeFilter = state.typeFilter;
-        const groupsToProcess = updatedGroups;
-        const itemsToProcess = updatedItems;
-        const hasGroupList = (groupList) => groupList && notEmpty(groupList);
-        const hasNoInternalSearchAndGroups = () => isEmpty(internalSearchValue) && hasGroupList(groupsToProcess);
-        const hasInternalSearchAndGroups = () => notEmpty(internalSearchValue) && hasGroupList(groupsToProcess);
-        const filteredItems = isEmpty(internalTypeFilter)
-            ? itemsToProcess
-            : filterAssetByType(itemsToProcess, internalTypeFilter);
-        const setGroupedItems = () => setGroupedItemList(groupsToProcess, filteredItems, showEmptyGroups);
-        const setFlatItems = () => setFlatItemList(filteredItems, internalSearchValue);
-        cond([
-            [hasNoInternalSearchAndGroups, setGroupedItems],
-            [hasInternalSearchAndGroups, setFlatItems],
-            [otherwise, setFlatItems],
-        ])();
-    };
-    const containerHeight = useTreeHeight(treeRef, scrollHeight);
-    const renderVirtualizedTree = () => {
-        const items = virtualizer.getVirtualItems();
-        const isGroupedList = hasGroups() && !hasInternalSearchValue();
-        return (_jsx(SmoothScrollbars, { ref: scrollElementRef, className: 'tree-virtual-scrollbar', onScroll: handleVirtualizedScroll, autoHeight: false, slideIn: true, style: {
-                height: `${containerHeight}px`,
-            }, children: _jsx("div", { className: isGroupedList ? 'grouped-list' : 'flat-list', style: {
-                    height: `${virtualizer.getTotalSize()}px`,
-                    position: 'relative',
-                }, children: items.map(virtualItem => {
-                    const item = virtualizedItems[virtualItem.index];
-                    if (!item) {
-                        return null;
-                    }
-                    const isGroupSelected = selectedGroups.includes(item.id) ||
-                        (item.type === 'leaf' && selectedGroups.includes(item.groupId));
-                    return (_jsx("div", { "data-index": virtualItem.index, ref: virtualizer.measureElement, className: `virtualized-tree-item ${item.type === 'group' ? 'group-item' : 'leaf-item'} ${isGroupSelected ? 'checked' : ''}`, style: {
-                            position: 'absolute',
-                            top: 0,
-                            left: 0,
-                            width: '100%',
-                            height: `${virtualItem.size}px`,
-                            transform: `translateY(${virtualItem.start}px)`,
-                        }, children: item.type === 'group' ? (_jsx(TreeNodeContainer, { groupId: item.id, isOpen: item.isExpanded, disableAnimation: disableAnimation, children: _jsx(TreeNode, { node: item.data, hasMultiselect: hasMultiselect, onToggleNode: enhancedHandleToggleNode, onSelect: handleGroupSelection, isSelected: isGroupSelected, isOpen: item.isExpanded, isIndeterminate: !isGroupSelected &&
-                                    item.data.items.some(groupItem => selectedItems.includes(groupItem.id)) }) }, item.id)) : (
-                        // Render individual leaf item with proper styling
-                        _jsx(TreeNodeContainer, { isOpen: true, disableAnimation: disableAnimation, children: _jsx(TreeLeafList, { leafList: [item.data], hasMultiselect: hasMultiselect, showRadioButtons: showRadioButtons, selectedItems: selectedItems, selectedGroups: selectedGroups, onSelectionChange: respondSelection }) }, item.id)) }, `${item.type}-${item.id}-${virtualItem.index}`));
-                }) }) }));
-    };
-    const renderTree = () => {
-        const { groupedItems } = state;
-        if (isEmpty(groupedItems)) {
-            return _jsx(TreeNothingFound, {});
-        }
-        if (virtualizedItems.length > virtualizeThreshold) {
-            return renderVirtualizedTree();
-        }
-        const result = map(groupedItems, (group) => {
-            const groupId = group.id;
-            const groupItems = group.items;
-            const isOpen = internalExpandedGroups?.includes(groupId) ?? false;
-            const numSelectedGroupItems = filter(groupItems, containsItemById(selectedItems)).length;
-            const isGroupSelected = selectedGroups.includes(groupId);
-            const isStateIndeterminate = !isGroupSelected && numSelectedGroupItems > 0;
-            return (_jsxs(TreeNodeContainer, { groupId: groupId, isOpen: isOpen, disableAnimation: disableAnimation, children: [_jsx(TreeNode, { node: group, hasMultiselect: hasMultiselect, onToggleNode: handleToggleNode, onSelect: handleGroupSelection, isSelected: isGroupSelected, isIndeterminate: isStateIndeterminate, isOpen: isOpen }), isOpen && (_jsx(TreeLeafList, { leafList: groupItems, hasMultiselect: hasMultiselect, showRadioButtons: showRadioButtons, selectedItems: selectedItems, selectedGroups: selectedGroups, onSelectionChange: respondSelection }))] }, groupId));
-        });
-        return result;
-    };
-    const renderFlatList = () => {
-        const { flatItems } = state;
-        const hasLeafs = isEmpty(flatItems);
-        if (virtualizedItems.length > virtualizeThreshold) {
-            return renderVirtualizedTree();
-        }
-        const getLeafs = () => (_jsx(TreeLeafList, { leafList: flatItems, hasMultiselect: hasMultiselect, showRadioButtons: showRadioButtons, selectedItems: selectedItems, selectedGroups: selectedGroups, onSelectionChange: respondSelection }));
-        return (_jsx(TreeNodeContainer, { disableAnimation: disableAnimation, isOpen: true, children: hasLeafs ? _jsx(TreeNothingFound, {}) : getLeafs() }));
-    };
-    const hasExternalGroups = notEmpty(groups);
-    const hasSelectedAllItems = () => isEqual(size(selectedItems), size(state.flatItems));
-    const hasPartiallySelectedItems = () => notEmpty(selectedItems) && !hasSelectedAllItems();
-    const hasSelectedAllGroups = () => {
-        const emptyGroupAmount = showEmptyGroups ? 0 : state.emptyGroups.length;
-        return isEqual(size(selectedGroups), size(groups) - emptyGroupAmount);
-    };
-    const hasPartiallySelectedGroups = () => hasExternalGroups && notEmpty(selectedGroups) && !hasSelectedAllGroups();
-    const hasSearchAndNoItems = hasInternalSearchValue() && isEmpty(state.flatItems);
-    const hasSearchAndNoGroups = hasInternalSearchValue() && isEmpty(state.groupedItems) && hasExternalGroups;
-    const hideSelectAll = hasSearchAndNoItems || hasSearchAndNoGroups;
-    const isIndeterminate = hasPartiallySelectedGroups() || hasPartiallySelectedItems();
-    const treeClassNames = classNames('Tree', className);
-    const treeHeadClasses = classNames('TreeHead', 'display-flex gap-5', 'padding-15');
-    const shouldRenderTree = () => hasGroups() && !hasInternalSearchValue();
-    const content = cond([
-        [shouldRenderTree, () => renderTree()],
-        [otherwise, () => renderFlatList()],
+  }, ae = (e, t) => {
+    const s = e.id, a = !i.includes(s) && !t ? [...i, s] : kt(i, s), h = gt(o.groupedItems, (_) => _.id === s), p = Y(h?.items, (_) => _.id), N = St(f, ...p), O = c.length, M = b ? 0 : o.emptyGroups.length, V = O - M === a.length;
+    d(v(V)), A(N, a);
+  }, De = (e) => {
+    Fe(e), d(Bt(e)), g && setTimeout(() => {
+      ke();
+    }, 10);
+  }, Me = (e, t) => {
+    const s = Ot(e, t);
+    d(Pt(s));
+  }, Ue = (e, t, s) => {
+    const r = Ft(e, t), l = ht(vt, bt)(r), a = s ? l : Lt(l), h = H(l, (p) => u(p.items));
+    d(zt(h)), d(Ie(ge(m))), d($t(a));
+  }, L = (e, t) => {
+    const s = o.searchValue, r = o.typeFilter, l = e, a = t, h = (V) => V && S(V), p = () => u(s) && h(l), N = () => S(s) && h(l), O = u(r) ? a : Et(a, r), M = () => Ue(l, O, b), U = () => Me(O, s);
+    q([
+      [p, M],
+      [N, U],
+      [Z, U]
     ])();
-    const handleFilterByType = (type) => {
-        const updatedTypeFilter = addOrRemoveFromList(state.typeFilter, type);
-        dispatch(typeFilterChanged(updatedTypeFilter));
-        onTypeFilterChange(updatedTypeFilter);
-    };
-    const enableActivity = size(state.visibleTypeCounters) !== 1;
-    const isFilterActive = notEmpty(state.typeFilter);
-    const showTreeHead = !hideTreeHead;
-    const showSelectAll = !hideSelectAll;
-    const showSearch = !hideSearch;
-    const showSummary = !hideSummary;
-    const hasCustomSearch = !isNil(search);
-    return (_jsxs("div", { ...remainingProps, className: treeClassNames, ref: treeRef, children: [_jsxs("div", { className: 'TreeHeader', children: [treeHeaderContent, showSearch && !hasCustomSearch && (_jsx(TreeSearch, { value: state.searchValue, onChange: handleSearchChange, placeholder: searchPlaceholder })), hasCustomSearch && search, showTreeHead && (_jsxs("div", { className: treeHeadClasses, children: [showSelectAll && (_jsx("div", { className: 'border border-right-only hidden-empty padding-right-10 margin-right-2', children: _jsx(TreeSelectAll, { isChecked: state.allChecked, isEnabled: hasMultiselect, isIndeterminate: isIndeterminate, onSelect: handleSelectAll }) })), _jsx("div", { className: 'display-flex justify-content-between align-items-start width-100pct', children: showSummary
-                                    ? summary || (_jsx(TreeSummary, { children: map(state.visibleTypeCounters, (typeCounter) => (_jsx(TypeCounter, { type: typeCounter, icon: `${typeCounter}`, value: state.assetCounts[typeCounter], onClick: handleFilterByType, isActive: state.typeFilter.includes(typeCounter), hasFilter: isFilterActive, enableActivity: enableActivity }, typeCounter))) }))
-                                    : null }), _jsx(TreeOptions, { treeOptions: treeOptions, treeOptionsTooltip: treeOptionsTooltip })] }))] }), _jsx(TreeRoot, { maxHeight: scrollHeight, disableAnimation: disableAnimation, children: content })] }));
-}, customCompare);
-export default Tree;
+  }, _e = Ut(se, ee), ie = () => {
+    const e = g.getVirtualItems(), t = C() && !T();
+    return /* @__PURE__ */ n(
+      qt,
+      {
+        ref: j,
+        className: "tree-virtual-scrollbar",
+        onScroll: we,
+        autoHeight: !1,
+        slideIn: !0,
+        style: {
+          height: `${_e}px`
+        },
+        children: /* @__PURE__ */ n(
+          "div",
+          {
+            className: t ? "grouped-list" : "flat-list",
+            style: {
+              height: `${g.getTotalSize()}px`,
+              position: "relative"
+            },
+            children: e.map((s) => {
+              const r = D[s.index];
+              if (!r)
+                return null;
+              const l = i.includes(r.id) || r.type === "leaf" && i.includes(r.groupId);
+              return /* @__PURE__ */ n(
+                "div",
+                {
+                  "data-index": s.index,
+                  ref: g.measureElement,
+                  className: `virtualized-tree-item ${r.type === "group" ? "group-item" : "leaf-item"} ${l ? "checked" : ""}`,
+                  style: {
+                    position: "absolute",
+                    top: 0,
+                    left: 0,
+                    width: "100%",
+                    height: `${s.size}px`,
+                    transform: `translateY(${s.start}px)`
+                  },
+                  children: r.type === "group" ? /* @__PURE__ */ n(
+                    w,
+                    {
+                      groupId: r.id,
+                      isOpen: r.isExpanded,
+                      disableAnimation: x,
+                      children: /* @__PURE__ */ n(
+                        he,
+                        {
+                          node: r.data,
+                          hasMultiselect: G,
+                          onToggleNode: He,
+                          onSelect: ae,
+                          isSelected: l,
+                          isOpen: r.isExpanded,
+                          isIndeterminate: !l && r.data.items.some((a) => f.includes(a.id))
+                        }
+                      )
+                    },
+                    r.id
+                  ) : (
+                    // Render individual leaf item with proper styling
+                    /* @__PURE__ */ n(w, { isOpen: !0, disableAnimation: x, children: /* @__PURE__ */ n(
+                      J,
+                      {
+                        leafList: [r.data],
+                        hasMultiselect: G,
+                        showRadioButtons: z,
+                        selectedItems: f,
+                        selectedGroups: i,
+                        onSelectionChange: A
+                      }
+                    ) }, r.id)
+                  )
+                },
+                `${r.type}-${r.id}-${s.index}`
+              );
+            })
+          }
+        )
+      }
+    );
+  }, qe = () => {
+    const { groupedItems: e } = o;
+    return u(e) ? /* @__PURE__ */ n(fe, {}) : D.length > te ? ie() : Y(e, (s) => {
+      const r = s.id, l = s.items, a = le?.includes(r) ?? !1, h = H(l, Vt(f)).length, p = i.includes(r), N = !p && h > 0;
+      return /* @__PURE__ */ R(w, { groupId: r, isOpen: a, disableAnimation: x, children: [
+        /* @__PURE__ */ n(
+          he,
+          {
+            node: s,
+            hasMultiselect: G,
+            onToggleNode: $,
+            onSelect: ae,
+            isSelected: p,
+            isIndeterminate: N,
+            isOpen: a
+          }
+        ),
+        a && /* @__PURE__ */ n(
+          J,
+          {
+            leafList: l,
+            hasMultiselect: G,
+            showRadioButtons: z,
+            selectedItems: f,
+            selectedGroups: i,
+            onSelectionChange: A
+          }
+        )
+      ] }, r);
+    });
+  }, Ze = () => {
+    const { flatItems: e } = o, t = u(e);
+    return D.length > te ? ie() : /* @__PURE__ */ n(w, { disableAnimation: x, isOpen: !0, children: t ? /* @__PURE__ */ n(fe, {}) : /* @__PURE__ */ n(
+      J,
+      {
+        leafList: e,
+        hasMultiselect: G,
+        showRadioButtons: z,
+        selectedItems: f,
+        selectedGroups: i,
+        onSelectionChange: A
+      }
+    ) });
+  }, de = S(c), Ye = () => W(y(f), y(o.flatItems)), Je = () => S(f) && !Ye(), Ke = () => {
+    const e = b ? 0 : o.emptyGroups.length;
+    return W(y(i), y(c) - e);
+  }, Qe = () => de && S(i) && !Ke(), We = T() && u(o.flatItems), Xe = T() && u(o.groupedItems) && de, et = We || Xe, tt = Qe() || Je(), st = me("Tree", ve), ot = me("TreeHead", "display-flex gap-5", "padding-15"), rt = q([
+    [() => C() && !T(), () => qe()],
+    [Z, () => Ze()]
+  ])(), nt = (e) => {
+    const t = Rt(o.typeFilter, e);
+    d(jt(t)), Oe(t);
+  }, lt = y(o.visibleTypeCounters) !== 1, ct = S(o.typeFilter), at = !Ce, it = !et, dt = !Ge, ut = !Ne, ue = !It(X);
+  return /* @__PURE__ */ R("div", { ...Re, className: st, ref: se, children: [
+    /* @__PURE__ */ R("div", { className: "TreeHeader", children: [
+      Ae,
+      dt && !ue && /* @__PURE__ */ n(
+        Tt,
+        {
+          value: o.searchValue,
+          onChange: De,
+          placeholder: Ee
+        }
+      ),
+      ue && X,
+      at && /* @__PURE__ */ R("div", { className: ot, children: [
+        it && /* @__PURE__ */ n("div", { className: "border border-right-only hidden-empty padding-right-10 margin-right-2", children: /* @__PURE__ */ n(
+          yt,
+          {
+            isChecked: o.allChecked,
+            isEnabled: G,
+            isIndeterminate: tt,
+            onSelect: Be
+          }
+        ) }),
+        /* @__PURE__ */ n("div", { className: "display-flex justify-content-between align-items-start width-100pct", children: ut ? xe || /* @__PURE__ */ n(Gt, { children: Y(o.visibleTypeCounters, (e) => /* @__PURE__ */ n(
+          xt,
+          {
+            type: e,
+            icon: `${e}`,
+            value: o.assetCounts[e],
+            onClick: nt,
+            isActive: o.typeFilter.includes(e),
+            hasFilter: ct,
+            enableActivity: lt
+          },
+          e
+        )) }) : null }),
+        /* @__PURE__ */ n(Ct, { treeOptions: be, treeOptionsTooltip: Le })
+      ] })
+    ] }),
+    /* @__PURE__ */ n(At, { maxHeight: ee, disableAnimation: x, children: rt })
+  ] });
+}, Zt);
+export {
+  Gs as default,
+  xs as getSubTypeCounts,
+  ge as getTypeCounts
+};
+//# sourceMappingURL=Tree.js.map