yanzhen-design-vue/lib/components/cascade/src/utils.cjs

"use strict";
Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
function getKey(key, pos) {
  if (key !== null && key !== void 0) {
    return key;
  }
  return pos;
}
function getPosition(level, index) {
  return `${level}-${index}`;
}
function traverseDataNodes(dataNodes, callback, fieldNames) {
  const { key: fieldKey = "key", children: fieldChildren } = fieldNames;
  const syntheticGetKey = (node, pos) => getKey(node[fieldKey], pos);
  function processNode(node, index, parent, pathNodes) {
    const children = node ? node[fieldChildren] : dataNodes;
    const pos = node ? getPosition(parent.pos, index) : "0";
    const connectNodes = node ? [...pathNodes, node] : [];
    if (node) {
      const key = syntheticGetKey(node, pos);
      const data = {
        node,
        index,
        pos,
        key,
        // @ts-ignore
        parentPos: parent.node ? parent.pos : null,
        // @ts-ignore
        level: parent.level + 1,
        nodes: connectNodes
      };
      callback(data);
    }
    if (children) {
      children.forEach((subNode, subIndex) => {
        processNode(
          subNode,
          subIndex,
          {
            node,
            pos,
            // @ts-ignore
            level: parent ? parent.level + 1 : -1
          },
          connectNodes
        );
      });
    }
  }
  return processNode(null);
}
function convertDataToEntities(dataNodes, {
  fieldNames,
  initWrapper,
  processEntity
}) {
  const posEntities = {};
  const keyEntities = {};
  let wrapper = {
    posEntities,
    keyEntities
  };
  if (initWrapper) {
    wrapper = initWrapper(wrapper) || wrapper;
  }
  traverseDataNodes(
    dataNodes,
    (item) => {
      const { node, index, pos, key, parentPos, level, nodes } = item;
      const entity = { node, nodes, index, key, pos, level };
      const mergedKey = getKey(key, pos);
      posEntities[pos] = entity;
      keyEntities[mergedKey] = entity;
      entity.parent = posEntities[parentPos];
      if (entity.parent) {
        entity.parent.children = entity.parent.children || [];
        entity.parent.children.push(entity);
      }
      if (processEntity) {
        processEntity(wrapper, entity);
      }
    },
    fieldNames
  );
  return wrapper;
}
function removeFromCheckedKeys(halfCheckedKeys, checkedKeys) {
  const filteredKeys = /* @__PURE__ */ new Set();
  halfCheckedKeys.forEach((key) => {
    if (!checkedKeys.has(key)) {
      filteredKeys.add(key);
    }
  });
  return filteredKeys;
}
function isCheckDisabled(node) {
  const { disabled, disableCheckbox, checkable } = node || {};
  return !!(disabled || disableCheckbox) || checkable === false;
}
function fillConductCheck(keys, levelEntities, maxLevel, syntheticGetCheckDisabled) {
  const checkedKeys = new Set(keys);
  const halfCheckedKeys = /* @__PURE__ */ new Set();
  for (let level = 0; level <= maxLevel; level += 1) {
    const entities = levelEntities.get(level) || /* @__PURE__ */ new Set();
    entities.forEach((entity) => {
      const { key, node, children = [] } = entity;
      if (checkedKeys.has(key) && !syntheticGetCheckDisabled(node)) {
        children.filter((childEntity) => !syntheticGetCheckDisabled(childEntity.node)).forEach((childEntity) => {
          checkedKeys.add(childEntity.key);
        });
      }
    });
  }
  const visitedKeys = /* @__PURE__ */ new Set();
  for (let level = maxLevel; level >= 0; level -= 1) {
    const entities = levelEntities.get(level) || /* @__PURE__ */ new Set();
    entities.forEach((entity) => {
      var _a;
      const { parent, node } = entity;
      if (syntheticGetCheckDisabled(node) || !entity.parent || visitedKeys.has(entity.parent.key)) {
        return;
      }
      if (syntheticGetCheckDisabled((_a = entity == null ? void 0 : entity.parent) == null ? void 0 : _a.node)) {
        visitedKeys.add(parent == null ? void 0 : parent.key);
        return;
      }
      let allChecked = true;
      let partialChecked = false;
      ((parent == null ? void 0 : parent.children) || []).filter((childEntity) => !syntheticGetCheckDisabled(childEntity.node)).forEach(({ key }) => {
        const checked = checkedKeys.has(key);
        if (allChecked && !checked) {
          allChecked = false;
        }
        if (!partialChecked && (checked || halfCheckedKeys.has(key))) {
          partialChecked = true;
        }
      });
      if (allChecked) {
        checkedKeys.add(parent == null ? void 0 : parent.key);
      }
      if (partialChecked) {
        halfCheckedKeys.add(parent == null ? void 0 : parent.key);
      }
      visitedKeys.add(parent == null ? void 0 : parent.key);
    });
  }
  return {
    checkedKeys: Array.from(checkedKeys),
    halfCheckedKeys: Array.from(removeFromCheckedKeys(halfCheckedKeys, checkedKeys))
  };
}
function cleanConductCheck(keys, halfKeys, levelEntities, maxLevel, syntheticGetCheckDisabled) {
  const checkedKeys = new Set(keys);
  let halfCheckedKeys = new Set(halfKeys);
  for (let level = 0; level <= maxLevel; level += 1) {
    const entities = levelEntities.get(level) || /* @__PURE__ */ new Set();
    entities.forEach((entity) => {
      const { key, node, children = [] } = entity;
      if (!checkedKeys.has(key) && !halfCheckedKeys.has(key) && !syntheticGetCheckDisabled(node)) {
        children.filter((childEntity) => !syntheticGetCheckDisabled(childEntity.node)).forEach((childEntity) => {
          checkedKeys.delete(childEntity.key);
        });
      }
    });
  }
  halfCheckedKeys = /* @__PURE__ */ new Set();
  const visitedKeys = /* @__PURE__ */ new Set();
  for (let level = maxLevel; level >= 0; level -= 1) {
    const entities = levelEntities.get(level) || /* @__PURE__ */ new Set();
    entities.forEach((entity) => {
      const { parent, node } = entity;
      if (syntheticGetCheckDisabled(node) || !entity.parent || visitedKeys.has(entity.parent.key)) {
        return;
      }
      if (syntheticGetCheckDisabled(entity.parent.node)) {
        visitedKeys.add(parent == null ? void 0 : parent.key);
        return;
      }
      let allChecked = true;
      let partialChecked = false;
      ((parent == null ? void 0 : parent.children) || []).filter((childEntity) => !syntheticGetCheckDisabled(childEntity.node)).forEach(({ key }) => {
        const checked = checkedKeys.has(key);
        if (allChecked && !checked) {
          allChecked = false;
        }
        if (!partialChecked && (checked || halfCheckedKeys.has(key))) {
          partialChecked = true;
        }
      });
      if (!allChecked) {
        checkedKeys.delete(parent == null ? void 0 : parent.key);
      }
      if (partialChecked) {
        halfCheckedKeys.add(parent == null ? void 0 : parent.key);
      }
      visitedKeys.add(parent == null ? void 0 : parent.key);
    });
  }
  return {
    checkedKeys: Array.from(checkedKeys),
    halfCheckedKeys: Array.from(removeFromCheckedKeys(halfCheckedKeys, checkedKeys))
  };
}
function conductCheck(keyList, checked, keyEntities, maxLevel, levelEntities) {
  const keys = new Set(
    keyList.filter((key) => {
      const hasEntity = !!keyEntities[key];
      return hasEntity;
    })
  );
  let result;
  if (checked === true) {
    result = fillConductCheck(keys, levelEntities, maxLevel, isCheckDisabled);
  } else {
    result = cleanConductCheck(
      keys,
      checked.halfCheckedKeys,
      levelEntities,
      maxLevel,
      isCheckDisabled
    );
  }
  return result;
}
function formatStrategyValues(pathKeys, keyPathEntities) {
  const valueSet = new Set(pathKeys);
  return pathKeys.filter((key) => {
    const entity = keyPathEntities[key];
    const children = entity ? entity.children : null;
    return !(children && children.some((child) => child.key && valueSet.has(child.key)));
  });
}
function isLeaf(option, fieldNames) {
  var _a;
  return option.isLeaf ?? !((_a = option[fieldNames.children]) == null ? void 0 : _a.length);
}
exports.conductCheck = conductCheck;
exports.convertDataToEntities = convertDataToEntities;
exports.formatStrategyValues = formatStrategyValues;
exports.getKey = getKey;
exports.getPosition = getPosition;
exports.isCheckDisabled = isCheckDisabled;
exports.isLeaf = isLeaf;
exports.traverseDataNodes = traverseDataNodes;