tdesign-react/esm/tree/hooks/useStore.js

TDesign Component for React

/**
 * tdesign v1.15.1
 * (c) 2025 tdesign
 * @license MIT
 */

import { _ as _slicedToArray } from '../../_chunks/dep-48805ab8.js';
import { useRef, useState, useEffect } from 'react';
import { cloneDeep } from 'lodash-es';
import { T as TreeStore } from '../../_chunks/dep-6b3ac896.js';
import useUpdateLayoutEffect from '../../hooks/useUpdateLayoutEffect.js';
import usePrevious from '../../hooks/usePrevious.js';
import { usePersistFn } from '../../hooks/usePersistFn.js';
import '../../_chunks/dep-026a4c6b.js';
import '../../_chunks/dep-cb0a3966.js';
import '../../_chunks/dep-eca3a3de.js';
import '../../_chunks/dep-83726008.js';
import 'mitt';
import '../../_chunks/dep-1d1c579e.js';
import '../../_chunks/dep-a74cc5e4.js';
import '../../_chunks/dep-e29214cb.js';
import '../../_chunks/dep-87d110df.js';
import '../../_chunks/dep-b908e1fe.js';
import '../../_chunks/dep-f53c91cd.js';
import '../../hooks/useIsFirstRender.js';
import '../../hooks/useLayoutEffect.js';
import '../../_chunks/dep-3a09424a.js';

function useStore(props, refresh) {
  var storeRef = useRef(null);
  var _useState = useState(false),
    _useState2 = _slicedToArray(_useState, 2),
    filterChanged = _useState2[0],
    toggleFilterChanged = _useState2[1];
  var _useState3 = useState(null),
    _useState4 = _slicedToArray(_useState3, 2),
    prevExpanded = _useState4[0],
    changePrevExpanded = _useState4[1];
  var data = props.data,
    keys = props.keys,
    expandAll = props.expandAll,
    expandParent = props.expandParent,
    expanded = props.expanded,
    expandLevel = props.expandLevel,
    expandMutex = props.expandMutex,
    activable = props.activable,
    activeMultiple = props.activeMultiple,
    actived = props.actived,
    disabled = props.disabled,
    draggable = props.draggable,
    checkable = props.checkable,
    value = props.value,
    checkStrictly = props.checkStrictly,
    load = props.load,
    lazy = props.lazy,
    valueMode = props.valueMode,
    filter = props.filter,
    _onLoad = props.onLoad,
    indeterminate = props.indeterminate,
    setTreeIndeterminate = props.setTreeIndeterminate,
    _props$allowFoldNodeO = props.allowFoldNodeOnFilter,
    allowFoldNodeOnFilter = _props$allowFoldNodeO === void 0 ? false : _props$allowFoldNodeO;
  var preFilter = usePrevious(filter);
  useEffect(function () {
    if (!allowFoldNodeOnFilter) return;
    toggleFilterChanged(JSON.stringify(preFilter) !== JSON.stringify(filter));
  }, [filter, allowFoldNodeOnFilter]);
  var expandFilterPath = function expandFilterPath() {
    if (!allowFoldNodeOnFilter || !filterChanged) return;
    toggleFilterChanged(false);
    var store2 = storeRef.current;
    if (props.filter) {
      if (!prevExpanded) changePrevExpanded(store2.getExpanded());
      var pathValues = [];
      var allNodes = store2.getNodes();
      allNodes.forEach(function (node) {
        if (node.vmIsLocked) {
          pathValues.push(node.value);
        }
      });
      store2.setExpanded(pathValues);
    } else if (prevExpanded) {
      store2.replaceExpanded(prevExpanded);
      changePrevExpanded(null);
    }
  };
  var handleUpdate = usePersistFn(function () {
    expandFilterPath();
    refresh();
  });
  var getExpandedArr = function getExpandedArr(arr, store2) {
    var expandedMap = /* @__PURE__ */new Map();
    arr.forEach(function (val) {
      expandedMap.set(val, true);
      if (expandParent) {
        var node = store2.getNode(val);
        node === null || node === void 0 || node.getParents().forEach(function (tn) {
          expandedMap.set(tn.value, true);
        });
      }
    });
    return Array.from(expandedMap.keys());
  };
  var createStore = function createStore() {
    var store2 = new TreeStore({
      keys: keys,
      activable: activable,
      activeMultiple: activeMultiple,
      checkable: checkable,
      checkStrictly: checkStrictly,
      expandAll: expandAll,
      expandLevel: expandLevel,
      expandMutex: expandMutex,
      expandParent: expandParent,
      disabled: disabled,
      draggable: draggable,
      load: load,
      lazy: lazy,
      valueMode: valueMode,
      filter: filter,
      onLoad: function onLoad(info) {
        var node = info.node;
        _onLoad === null || _onLoad === void 0 || _onLoad({
          node: node.getModel()
        });
      },
      onUpdate: handleUpdate,
      allowFoldNodeOnFilter: allowFoldNodeOnFilter
    });
    var list = cloneDeep(data);
    if (!Array.isArray(list)) {
      list = [];
    }
    store2.append(list);
    store2.refreshNodes();
    if (Array.isArray(value)) {
      store2.setChecked(value);
    }
    if (Array.isArray(expanded)) {
      var expandedArr = getExpandedArr(expanded, store2);
      store2.setExpanded(expandedArr);
    }
    if (Array.isArray(actived)) {
      store2.setActived(actived);
    }
    store2.refreshNodes();
    return store2;
  };
  if (!storeRef.current) {
    storeRef.current = createStore();
  }
  var store = storeRef.current;
  useUpdateLayoutEffect(function () {
    if (data && Array.isArray(data)) {
      var expanded2 = store.getExpanded();
      var checked = store.getChecked();
      var actived2 = store.getActived();
      store.removeAll();
      store.append(data);
      store.setChecked(checked);
      store.setActived(actived2);
      store.setExpanded(expanded2);
    }
  }, [data, store]);
  useUpdateLayoutEffect(function () {
    store.setConfig({
      keys: keys,
      expandAll: expandAll,
      expandLevel: expandLevel,
      expandMutex: expandMutex,
      expandParent: expandParent,
      activable: activable,
      activeMultiple: activeMultiple,
      disabled: disabled,
      checkable: checkable,
      draggable: draggable,
      checkStrictly: checkStrictly,
      load: load,
      lazy: lazy,
      valueMode: valueMode
    });
    store.refreshState();
  }, [activable, activeMultiple, checkStrictly, draggable, checkable, disabled, expandAll, expandLevel, expandMutex, expandParent, keys, lazy, load, store, valueMode]);
  useUpdateLayoutEffect(function () {
    if (expandAll) {
      var valueList = store.getNodes().filter(function (node) {
        return Array.isArray(node.children) && node.children.length;
      }).map(function (node) {
        return node.value;
      });
      store.setExpanded(valueList);
    } else {
      store.replaceExpanded(prevExpanded);
      changePrevExpanded(null);
    }
  }, [store, expandAll]);
  useUpdateLayoutEffect(function () {
    if (Array.isArray(value)) {
      store.replaceChecked(value);
      var checkedValue = store.getCheckedNodes().map(function (v) {
        return v.data[(keys === null || keys === void 0 ? void 0 : keys.value) || "value"];
      });
      var indeterminateConflict = checkedValue.filter(function (v) {
        return indeterminate.includes(v);
      });
      if (indeterminateConflict.length) {
        setTreeIndeterminate(indeterminate.filter(function (v) {
          return !indeterminateConflict.includes(v);
        }));
      }
    }
  }, [store, value, data]);
  useUpdateLayoutEffect(function () {
    if (Array.isArray(expanded)) {
      var expandedArr = getExpandedArr(expanded, store);
      store.replaceExpanded(expandedArr);
    }
  }, [expanded, store]);
  useUpdateLayoutEffect(function () {
    if (Array.isArray(actived)) {
      store.replaceActived(actived);
    }
  }, [actived, store]);
  useUpdateLayoutEffect(function () {
    if (Array.isArray(indeterminate)) {
      store.replaceIndeterminate(indeterminate);
    }
  }, [indeterminate, store, data]);
  useUpdateLayoutEffect(function () {
    store.setConfig({
      filter: filter
    });
    store.updateAll();
  }, [filter, store]);
  return storeRef.current;
}

export { useStore };
//# sourceMappingURL=useStore.js.map