xdesign-vue-next/es/cascader/core/effect.mjs

XDesign Component for vue-next

/**
 * xdesign v1.0.6
 * (c) 2023 xdesign
 * @license MIT
 */

import { _ as _slicedToArray } from '../../_chunks/dep-32d4c595.mjs';
import { i as isNumber_1 } from '../../_chunks/dep-23f91684.mjs';
import { i as isFunction_1 } from '../../_chunks/dep-1cc1c24f.mjs';
import { i as isArray_1 } from '../../_chunks/dep-a95026f2.mjs';
import { c as cloneDeep_1 } from '../../_chunks/dep-91ac8f71.mjs';
import { getFullPathLabel, getTreeValue } from './helper.mjs';
import '../../_chunks/dep-89b966f4.mjs';
import '../../_chunks/dep-10a947a6.mjs';
import '../../_chunks/dep-b75d8d74.mjs';
import '../../_chunks/dep-82805301.mjs';
import '../../_chunks/dep-addc2a84.mjs';
import '../../_chunks/dep-6ad18815.mjs';
import '../../_chunks/dep-c4737535.mjs';
import '../../_chunks/dep-81c83986.mjs';
import '../../_chunks/dep-6aa0223b.mjs';
import '../../_chunks/dep-db381ece.mjs';
import '../../_chunks/dep-5755c21c.mjs';
import '../../_chunks/dep-7f239c43.mjs';
import '../../_chunks/dep-6f04869e.mjs';
import '../../_chunks/dep-d32fbbb3.mjs';
import '../../_chunks/dep-dafada74.mjs';
import '../../_chunks/dep-068e912d.mjs';
import '../../_chunks/dep-6e7b37b8.mjs';
import '../../_chunks/dep-e1ab85c5.mjs';
import '../../_chunks/dep-5f0e0453.mjs';
import '../../_chunks/dep-71f84cf2.mjs';
import '../../_chunks/dep-0e832fc7.mjs';
import '../../_chunks/dep-69963a8c.mjs';
import '../../_chunks/dep-8d1c9a23.mjs';
import '../../_chunks/dep-03412fab.mjs';
import '../../_chunks/dep-205ff58d.mjs';
import '../../_chunks/dep-9d7ebc32.mjs';

function expendClickEffect(propsTrigger, trigger, node, cascaderContext) {
  var checkStrictly = cascaderContext.checkStrictly,
    multiple = cascaderContext.multiple,
    treeStore = cascaderContext.treeStore,
    setVisible = cascaderContext.setVisible,
    setValue = cascaderContext.setValue,
    setTreeNodes = cascaderContext.setTreeNodes,
    setExpend = cascaderContext.setExpend,
    value = cascaderContext.value,
    max = cascaderContext.max,
    valueType = cascaderContext.valueType;
  var isDisabled = node.disabled || multiple && value.length >= max && max !== 0;
  if (isDisabled) return;
  if (propsTrigger === trigger && !node.isLeaf()) {
    var expanded = node.setExpanded(true);
    treeStore.refreshNodes();
    treeStore.replaceExpanded(expanded);
    var nodes = treeStore.getNodes().filter(function (node2) {
      return node2.visible;
    });
    setTreeNodes(nodes);
    if (multiple) {
      setExpend(expanded);
    }
  }
  if (!multiple && (node.isLeaf() || checkStrictly) && trigger === "click") {
    treeStore.resetChecked();
    var checked = node.setChecked(!node.checked);
    var _checked = _slicedToArray(checked, 1),
      value2 = _checked[0];
    setValue(valueType === "single" ? value2 : node.getPath().map(function (item) {
      return item.value;
    }), "check", node.getModel());
    if (!checkStrictly) {
      setVisible(false, {});
    }
  }
}
function valueChangeEffect(node, cascaderContext) {
  var disabled = cascaderContext.disabled,
    max = cascaderContext.max,
    inputVal = cascaderContext.inputVal,
    multiple = cascaderContext.multiple,
    setVisible = cascaderContext.setVisible,
    setValue = cascaderContext.setValue,
    treeNodes = cascaderContext.treeNodes,
    treeStore = cascaderContext.treeStore,
    valueType = cascaderContext.valueType;
  if (!node || disabled || node.disabled) {
    return;
  }
  var checked = node.setChecked(!node.isChecked());
  if (isNumber_1(max) && max < 0) {
    console.warn("TDesign Warn:", "max should > 0");
  }
  if (checked.length > max && isNumber_1(max) && max > 0) {
    return;
  }
  if (checked.length === 0) {
    var expanded = treeStore.getExpanded();
    setTimeout(function () {
      treeStore.replaceExpanded(expanded);
      treeStore.refreshNodes();
    }, 0);
  }
  if (!multiple) {
    setVisible(false, {});
  }
  var isSelectAll = treeNodes.every(function (item) {
    return checked.indexOf(item.value) > -1;
  });
  if (inputVal && isSelectAll) {
    setVisible(false, {});
  }
  var resValue = valueType === "single" ? checked : checked.map(function (val) {
    return treeStore.getNode(val).getPath().map(function (item) {
      return item.value;
    });
  });
  setValue(resValue, "check", node.getModel());
}
function closeIconClickEffect(cascaderContext) {
  var setVisible = cascaderContext.setVisible,
    multiple = cascaderContext.multiple,
    setExpend = cascaderContext.setExpend,
    setValue = cascaderContext.setValue;
  setVisible(false, {});
  if (multiple) {
    setExpend([]);
  }
  setValue(multiple ? [] : "", "clear");
}
function handleRemoveTagEffect(cascaderContext, index, onRemove) {
  var disabled = cascaderContext.disabled,
    setValue = cascaderContext.setValue,
    value = cascaderContext.value,
    valueType = cascaderContext.valueType,
    treeStore = cascaderContext.treeStore;
  if (disabled) return;
  var newValue = cloneDeep_1(value);
  var res = newValue.splice(index, 1);
  var node = treeStore.getNodes(res[0])[0];
  setValue(newValue, "uncheck", node.getModel());
  var checked = node.setChecked(!node.isChecked());
  var resValue = valueType === "single" ? checked : checked.map(function (val) {
    return treeStore.getNode(val).getPath().map(function (item) {
      return item.value;
    });
  });
  setValue(resValue, "uncheck", node.getModel());
  if (isFunction_1(onRemove)) {
    onRemove({
      value: checked,
      node: node
    });
  }
}
var treeNodesEffect = function treeNodesEffect(inputVal, treeStore, setTreeNodes, filter) {
  if (!treeStore) return;
  var nodes = [];
  if (inputVal) {
    var filterMethods = function filterMethods(node) {
      if (!node.isLeaf()) return;
      if (isFunction_1(filter)) {
        return filter("".concat(inputVal), node);
      }
      var fullPathLabel = getFullPathLabel(node, "");
      return fullPathLabel.indexOf("".concat(inputVal)) > -1;
    };
    nodes = treeStore.nodes.filter(filterMethods);
  } else {
    nodes = treeStore.getNodes().filter(function (node) {
      return node.visible;
    });
  }
  setTreeNodes(nodes);
};
var treeStoreExpendEffect = function treeStoreExpendEffect(treeStore, value, expend) {
  var treeValue = getTreeValue(value);
  if (!treeStore) return;
  if (isArray_1(treeValue) && expend.length === 0) {
    var expandedMap = /* @__PURE__ */new Map();
    var _treeValue = _slicedToArray(treeValue, 1),
      val = _treeValue[0];
    if (val) {
      expandedMap.set(val, true);
      var node = treeStore.getNode(val);
      if (!node) {
        treeStore.refreshNodes();
        return;
      }
      node.getParents().forEach(function (tn) {
        expandedMap.set(tn.value, true);
      });
      var expandedArr = Array.from(expandedMap.keys());
      treeStore.replaceExpanded(expandedArr);
    } else {
      treeStore.resetExpanded();
    }
  }
  if (treeStore.getExpanded() && expend.length) {
    treeStore.replaceExpanded(expend);
  }
  treeStore.refreshNodes();
};

export { closeIconClickEffect, expendClickEffect, handleRemoveTagEffect, treeNodesEffect, treeStoreExpendEffect, valueChangeEffect };
//# sourceMappingURL=effect.mjs.map