linkmore-design/lib/lm-table/hooks/useDndItems.js

🌈 🚀lm组件库。🚀

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
var _react = require("react");
var _index = require("../common/index");
function del(arr, target) {
  if (!arr || !arr.length) {
    return null;
  }
  const index = arr.findIndex(item => item === target);
  if (index !== -1) {
    arr.splice(index, 1);
  }
}
function getSortInsert(tableHeader, value, {
  columns
}) {
  if (!tableHeader) {
    return [];
  }
  const arr = new Array(columns.length);
  tableHeader.push(value);
  tableHeader.forEach(val => {
    const index = columns.findIndex(item => item.title === val);
    columns[index].show = true;
    arr.splice(index, 0, val);
  });
  return arr.filter(Boolean);
}
function getSortDndColumns(value, {
  columns
}) {
  const tableHeader = value.tableHeader;
  let hiddenArr = [];
  if (value.row) {
    hiddenArr = [...hiddenArr, ...value.row];
  }
  if (value.col) {
    hiddenArr = [...hiddenArr, ...value.col];
  }
  if (!tableHeader || !tableHeader.length) {
    return [];
  }
  const result = [];
  for (let i = 0; i < tableHeader.length; i++) {
    const item = columns.find(item => item.title === tableHeader[i]);
    if (item) {
      item.order = i;
      result.push(item);
    }
  }
  for (let i = 0; i < hiddenArr.length; i++) {
    const item = columns.find(item => item.title === hiddenArr[i]);
    if (item) {
      item.show = false;
      result.push(item);
    }
  }
  return result;
}
function getDataIndexForTitle(row, columns) {
  if (!row) {
    return [];
  }
  return row.map(title => {
    const col = columns.find(item => item.title === title);
    if (col) {
      return col.dataIndex;
    }
  });
}
function useDndItems(props) {
  const {
    columns,
    colSortOpen,
    filterChange,
    openRowGroup,
    openColGroup,
    customizeGroupRowKeys,
    customizeGroupColKeys
  } = props;
  const [dndColumns, setDndColumns] = (0, _react.useState)(columns);
  const [groupRowKeys, setGroupRowKeys] = (0, _react.useState)(customizeGroupRowKeys || []);
  const [groupColKeys, setGroupColKeys] = (0, _react.useState)(customizeGroupColKeys || []);
  (0, _react.useEffect)(() => {
    if (customizeGroupRowKeys) {
      setGroupRowKeys(customizeGroupRowKeys);
    }
    if (customizeGroupColKeys) {
      setGroupColKeys(customizeGroupColKeys);
    }
  }, [customizeGroupRowKeys, customizeGroupColKeys]);

  // 初始化
  let defaultItems = {
    tableHeader: []
  };
  if (openRowGroup) {
    defaultItems.row = [];
  }
  if (openColGroup) {
    defaultItems.col = [];
  }
  if (openColGroup || openRowGroup || colSortOpen) {
    (0, _index.treeFind)(columns, node => {
      if (openRowGroup && groupRowKeys.includes(node.dataIndex)) {
        defaultItems.row && defaultItems.row.push(node.title);
      } else if (groupColKeys.includes(node.dataIndex)) {
        defaultItems.col && defaultItems.col.push(node.title);
      } else {
        defaultItems.tableHeader.push(node.title);
      }
      return false;
    });
  }
  const [items, setItems] = (0, _react.useState)(defaultItems);
  (0, _react.useEffect)(() => {
    if (customizeGroupRowKeys || customizeGroupColKeys) {
      columns.forEach(c => {
        if (customizeGroupRowKeys.includes(c.dataIndex) || customizeGroupColKeys.includes(c.dataIndex)) {
          c.show = false;
        }
      });
    }
    setDndColumns(columns);
    setItems(defaultItems);
  }, [columns]);

  // 更新
  const updateItems = (value, resume) => {
    if (value.row) {
      value.row = value?.row.filter(Boolean);
    }
    if (value.col) {
      value.col = value.col.filter(Boolean);
    }
    if (resume) {
      // 删除
      del(value.row, resume);
      del(value.col, resume);
      value.tableHeader = getSortInsert(value.tableHeader, resume, {
        columns: columns
      });
    }
    // 列分组进行覆盖，只允许存在一个
    if (value?.col?.length >= 2) {
      value.tableHeader = getSortInsert(value.tableHeader, items.col[0], {
        columns: columns
      });
      value.col = value.col.filter(item => item !== items.col[0]);
    }
    setItems(value);
    setGroupRowKeys(getDataIndexForTitle(value.row, columns));
    setGroupColKeys(getDataIndexForTitle(value.col, columns));
    const newColumns = getSortDndColumns(value, {
      columns: columns
    });
    setDndColumns(newColumns);
    filterChange?.(newColumns);
  };
  return {
    dndColumns,
    items,
    groupRowKeys,
    groupColKeys,
    updateItems
  };
}
var _default = useDndItems;
exports.default = _default;