linkmore-design/lib/lm-filter/utils.js

🌈 🚀lm组件库。🚀

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getFilterShow = getFilterShow;
exports.getFilterShowQuery = getFilterShowQuery;
exports.getFlatItem = getFlatItem;
exports.getIsHas = getIsHas;
exports.getRanges = getRanges;
exports.getValueForType = getValueForType;
exports.toStringIsEqual = toStringIsEqual;
exports.uniqueFunc = uniqueFunc;
var _dayjs = _interopRequireDefault(require("dayjs"));
// 检查是否存在内容
function getIsHas(val) {
  // 检查是否数字类型, 是否布尔类型
  let flag = !!val || typeof val === 'number' || typeof val === 'boolean';
  // 检查空对象和空数组
  if (!!val && typeof val === 'object') {
    flag = Array.isArray(val) ? !!val.length : !!Object.keys(val)?.length;
  }
  return flag;
}

/*
 * 数据(布尔值、数值)转字符串后对比是否相等 str, strs, type
 * @params {Array | String} strs
 * @params {String} type 比对类型
 * @type includes 是否包含在数组内
 */
function toStringIsEqual(str, strs, type) {
  if (type === 'includes') {
    return strs?.some(v => toStringIsEqual(str, v));
  }
  return String(str) === String(strs);
}

// 根据类型返回对应的值
function getValueForType(type) {
  if (['checkbox', 'cascader'].includes(type)) {
    return [];
  }
  return '';
}

// 数组对象去重
function uniqueFunc(arr, guid) {
  const res = new Map();
  return arr.filter(item => {
    const isHas = item?.[guid] || typeof item?.[guid] === 'number';
    const resetItem = isHas ? item?.[guid] : item;
    return !res.has(resetItem) && res.set(resetItem, 1);
  });
}

// 获取最近的时间段
function getRanges() {
  return {
    近一周: [(0, _dayjs.default)().subtract(7, 'day').format('YYYY-MM-DD'), (0, _dayjs.default)().format('YYYY-MM-DD')],
    近一月: [(0, _dayjs.default)().subtract(1, 'month').format('YYYY-MM-DD'), (0, _dayjs.default)().format('YYYY-MM-DD')],
    近一年: [(0, _dayjs.default)().subtract(1, 'year').format('YYYY-MM-DD'), (0, _dayjs.default)().format('YYYY-MM-DD')]
  };
}

// 级联选择器获取深层结构数据 type: 遍历子/父结构
function getFlatItem(getItem, checkedValue, type = 'children') {
  const filterValues = getItem?.props?.multiple ? checkedValue : [checkedValue];
  const originArr = getItem?.data || [];

  // 用于自定义读取的字段
  const fieldNames = {
    label: 'label',
    value: 'value',
    children: 'children',
    ...(getItem?.props?.fieldNames || {})
  };
  const nArr = [];

  // 获取子级项
  const getChildren = item => {
    if (!item) return;
    if (type === 'parent') {
      nArr.push(item);
      return;
    }
    if (item?.[fieldNames.children]?.length) {
      item?.[fieldNames.children].forEach(v => getChildren(v));
    } else {
      nArr.push(item);
    }
  };

  // 检测到三级结构
  filterValues.forEach(item => {
    if (item.length === 1) {
      const findItem = originArr?.find(v => toStringIsEqual(v?.[fieldNames.value], item[item.length - 1]));
      getChildren(findItem);
    }
    if (item.length === 2) {
      const findArr1 = originArr?.find(v => toStringIsEqual(v?.[fieldNames.value], item[0]))?.[fieldNames.children];
      const findItem = findArr1?.find(v => toStringIsEqual(v?.[fieldNames.value], item[item.length - 1]));
      getChildren(findItem);
    }
    if (item.length === 3) {
      const findArr1 = originArr?.find(v => toStringIsEqual(v?.[fieldNames.value], item[0]))?.[fieldNames.children];
      const findArr2 = findArr1?.find(v => toStringIsEqual(v?.[fieldNames.value], item[1]))?.[fieldNames.children];
      const findItem = findArr2?.find(v => toStringIsEqual(v?.[fieldNames.value], item[item.length - 1]));
      nArr.push(findItem);
    }
  });
  return nArr;
}

// 返回过滤掉隐藏字段后的查询结构 () => {...}
function getFilterShow(basicFilter, dataSource) {
  return Object.keys(basicFilter).reduce((pre, cur) => {
    const value = basicFilter[cur];
    if (dataSource.some(v => v.field === cur && (v.show || typeof v.show !== 'boolean'))) {
      // eslint-disable-next-line no-param-reassign
      pre[cur] = value;
    }
    return pre;
  }, {});
}

// 返回过滤掉隐藏字段后的查询结构 () => [...]
function getFilterShowQuery(basicQuery, dataSource) {
  return Object.keys(basicQuery).reduce((pre, cur) => {
    const value = basicQuery[cur];
    if (dataSource.some(v => v.field === cur && v.show || typeof v.show !== 'boolean')) {
      return [...pre, value];
    }
    return pre;
  }, []);
}