tdesign-react 0.34.4 → 0.34.5-alpha.3

package/lib/table/hooks/tree-store.js

@@ -1,5 +1,5 @@
 /**
- * tdesign v0.34.4
+ * tdesign v0.34.5-alpha.3
  * (c) 2022 tdesign
  * @license MIT
  */
@@ -8,29 +8,33 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var toConsumableArray = require('../../_chunks/dep-f6a4bdd5.js');
-var createClass = require('../../_chunks/dep-b8367f2e.js');
-var defineProperty = require('../../_chunks/dep-a1655de1.js');
-var get = require('../../_chunks/dep-3181fd9f.js');
+var toConsumableArray = require('../../_chunks/dep-582b78b0.js');
+var createClass = require('../../_chunks/dep-fc78f9e2.js');
+var defineProperty = require('../../_chunks/dep-9ac60bf6.js');
+var get = require('../../_chunks/dep-818d4cf0.js');
 var table_utils = require('../utils.js');
 var _common_js_log_log = require('../../_common/js/log/log.js');
-require('../../_chunks/dep-19841e1d.js');
-require('../../_chunks/dep-8a3a8f07.js');
-require('../../_chunks/dep-c90cc28f.js');
-require('../../_chunks/dep-3405bda4.js');
-require('../../_chunks/dep-cb0f33ac.js');
-require('../../_chunks/dep-fcf32c81.js');
-require('../../_chunks/dep-b1a67107.js');
-require('../../_chunks/dep-3b69722d.js');
-require('../../_chunks/dep-fde4d28a.js');
-require('../../_chunks/dep-e266830c.js');
-require('../../_chunks/dep-15a4424e.js');
-require('../../_chunks/dep-c40d75ac.js');
-require('../../_chunks/dep-86abec96.js');
+require('../../_chunks/dep-82c0c855.js');
+require('../../_chunks/dep-36ec78f4.js');
+require('../../_chunks/dep-0edeac4a.js');
+require('../../_chunks/dep-803c8dd6.js');
+require('../../_chunks/dep-077e63c2.js');
+require('../../_chunks/dep-b8e5e98a.js');
+require('../../_chunks/dep-34a986ee.js');
+require('../../_chunks/dep-52c72381.js');
+require('../../_chunks/dep-4467833d.js');
+require('../../_chunks/dep-33771610.js');
+require('../../_chunks/dep-9b8b8448.js');
+require('../../_chunks/dep-593af256.js');
+require('../../_chunks/dep-51d09add.js');
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { defineProperty._defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+var TABLE_TREE_ERROR_CODE_NOT_SAME_LEVEL = {
+  code: 1001,
+  reason: "The same level of rows can not be swapped."
+};
 
 var TableTreeStore = /*#__PURE__*/function () {
   function TableTreeStore() {
@@ -47,7 +51,7 @@ var TableTreeStore = /*#__PURE__*/function () {
       var _this$treeDataMap;
 
       (_this$treeDataMap = this.treeDataMap) === null || _this$treeDataMap === void 0 ? void 0 : _this$treeDataMap.clear();
-      initialTreeDataMap(this.treeDataMap, dataSource, columns[0], keys);
+      this.initialTreeDataMap(this.treeDataMap, dataSource, columns[0], keys);
     }
   }, {
     key: "toggleExpandData",
@@ -64,11 +68,7 @@ var TableTreeStore = /*#__PURE__*/function () {
         return [];
       }
 
-      var r = this.treeDataMap.get(rowValue) || {
-        row: p.row,
-        rowIndex: p.rowIndex,
-        expanded: false
-      };
+      var r = this.treeDataMap.get(rowValue);
       r.rowIndex = p.rowIndex;
       r.expanded = !r.expanded;
       this.treeDataMap.set(rowValue, r);
@@ -108,12 +108,12 @@ var TableTreeStore = /*#__PURE__*/function () {
     }
   }, {
     key: "updateData",
-    value: function updateData(key, newRowData, dataSource, keys) {
-      var newKey = get.get_1(newRowData, keys.rowKey);
-      var rowState = this.treeDataMap.get(key);
+    value: function updateData(rowValue, newRowData, dataSource, keys) {
+      var newRowValue = get.get_1(newRowData, keys.rowKey);
+      var rowState = this.treeDataMap.get(rowValue);
 
       if (!rowState || rowState.rowIndex === -1) {
-        updateRowData(dataSource, key, newRowData, {
+        updateRowData(dataSource, rowValue, newRowData, {
           rowKey: keys.rowKey,
           childrenKey: keys.childrenKey
         });
@@ -122,21 +122,20 @@ var TableTreeStore = /*#__PURE__*/function () {
 
       var currentRowIndex = rowState.rowIndex;
       rowState.row = newRowData;
-      this.treeDataMap.set(key, rowState);
+      rowState.id = newRowValue;
 
       if (rowState.parent) {
         var siblings = get.get_1(rowState.parent.row, keys.childrenKey);
         var index = siblings.findIndex(function (item) {
-          return get.get_1(item, keys.rowKey) === key;
+          return get.get_1(item, keys.rowKey) === rowValue;
         });
         siblings[index] = newRowData;
       }
 
-      if (key !== newKey) {
-        this.treeDataMap.set(newKey, rowState);
-        this.treeDataMap["delete"](key);
-      } else {
-        this.treeDataMap.set(key, rowState);
+      this.treeDataMap.set(newRowValue, rowState);
+
+      if (rowValue !== newRowValue) {
+        this.treeDataMap["delete"](rowValue);
       }
 
       return currentRowIndex;
@@ -156,50 +155,42 @@ var TableTreeStore = /*#__PURE__*/function () {
             return get.get_1(item, keys.rowKey) === key;
           });
           siblings.splice(index, 1);
-          updateRowExpandLength(this.treeDataMap, r.parent.row, -1 * removeNumber, "delete", {
-            rowKey: keys.rowKey,
-            childrenKey: keys.childrenKey
-          });
+          updateRowExpandLength(this.treeDataMap, r.parent.row, -1 * removeNumber, "delete", keys);
         }
 
         this.treeDataMap["delete"](key);
         updateRowIndex(this.treeDataMap, dataSource, {
           minRowIndex: r.rowIndex,
-          rowKey: keys.rowKey
+          rowKey: keys.rowKey,
+          type: "remove"
         });
       } else {
-        console.warn("TDesign Table Warn: Do not remove this node, which is not appreared.");
+        console.warn("TDesign Table Warn: Do not remove this node, which is not appeared.");
       }
 
       return dataSource;
     }
   }, {
     key: "appendTo",
-    value: function appendTo(key, newData, dataSource, keys) {
-      var state = this.treeDataMap.get(key);
-
-      if (!state) {
-        console.warn("TDesign Table Warn: ".concat(key, " is not exist."));
-        return;
-      }
-
+    value: function appendTo(rowValue, newData, dataSource, keys) {
+      var state = this.treeDataMap.get(rowValue);
+      if (!this.validateDataExist(state, rowValue)) return dataSource;
       var newRowValue = get.get_1(newData, keys.rowKey);
-
-      if (this.treeDataMap.get(newRowValue)) {
-        console.warn("TDesign Table Warn: Duplicated Key. ".concat(newRowValue, " is already exists."));
-        return;
-      }
-
+      var mapState = this.treeDataMap.get(newRowValue);
+      if (!this.validateDataDoubleExist(mapState, newRowValue)) return dataSource;
       var children = get.get_1(state.row, keys.childrenKey);
       var isShowNewNode = state.expanded || !(children !== null && children !== void 0 && children.length);
+      var rowIndex = isShowNewNode ? state.rowIndex + (state.expandChildrenLength || 0) + 1 : -1;
       var newState = {
+        id: newRowValue,
         row: newData,
+        rowIndex: rowIndex,
         level: state.level + 1,
-        parent: state,
-        path: toConsumableArray._toConsumableArray(state.path),
         expanded: false,
         expandChildrenLength: 0,
-        rowIndex: isShowNewNode ? state.rowIndex + (state.expandChildrenLength || 0) + 1 : -1
+        disabled: false,
+        path: toConsumableArray._toConsumableArray(state.path),
+        parent: state
       };
       newState.path = newState.path.concat(newState);
 
@@ -220,43 +211,345 @@ var TableTreeStore = /*#__PURE__*/function () {
         });
         updateRowIndex(this.treeDataMap, dataSource, {
           minRowIndex: newState.rowIndex,
-          rowKey: keys.rowKey
+          rowKey: keys.rowKey,
+          type: "add"
         });
       }
 
       return dataSource;
     }
-  }]);
+  }, {
+    key: "appendToRoot",
+    value: function appendToRoot(newData, dataSource, keys) {
+      var rowValue = get.get_1(newData, keys.rowKey);
 
-  return TableTreeStore;
-}();
-function initialTreeDataMap(treeDataMap, dataSource, column, keys) {
-  for (var i = 0, len = dataSource.length; i < len; i++) {
-    var item = dataSource[i];
-    var rowValue = get.get_1(item, keys.rowKey);
+      if (!rowValue) {
+        _common_js_log_log["default"].error("Table", "`rowKey` could be wrong, can not get rowValue from `data` by `rowKey`.");
+        return;
+      }
 
-    if (rowValue === void 0) {
-      _common_js_log_log["default"].error("EnhancedTable", "`rowKey` could be wrong, can not get rowValue from `data` by `rowKey`.");
-      return;
+      dataSource.push(newData);
+      var state = {
+        id: rowValue,
+        row: newData,
+        rowIndex: dataSource.length - 1,
+        level: 0,
+        expanded: false,
+        expandChildrenLength: 0,
+        disabled: false
+      };
+      state.path = [state];
+      this.treeDataMap.set(rowValue, state);
+      return dataSource;
+    }
+  }, {
+    key: "insertAfter",
+    value: function insertAfter(rowValue, newData, dataSource, keys) {
+      return this.insert(rowValue, newData, dataSource, keys, "after");
+    }
+  }, {
+    key: "insertBefore",
+    value: function insertBefore(rowValue, newData, dataSource, keys) {
+      return this.insert(rowValue, newData, dataSource, keys, "before");
     }
+  }, {
+    key: "insert",
+    value: function insert(rowValue, newData, dataSource, keys, type) {
+      var state = this.treeDataMap.get(rowValue);
+      if (!this.validateDataExist(state, rowValue)) return dataSource;
+      var newRowValue = get.get_1(newData, keys.rowKey);
+      var mapState = this.treeDataMap.get(newRowValue);
+      if (!this.validateDataDoubleExist(mapState, newRowValue)) return dataSource;
+      var rowIndex = type === "after" ? state.rowIndex + 1 : state.rowIndex;
+      var newState = {
+        id: newRowValue,
+        row: newData,
+        rowIndex: rowIndex,
+        level: state.level,
+        expanded: false,
+        expandChildrenLength: 0,
+        disabled: false,
+        path: state.path.slice(0, -1),
+        parent: state.parent
+      };
+      newState.path = newState.path.concat(newState);
+      var dataIndex = type === "after" ? state.rowIndex + (state.expandChildrenLength + 1) : state.rowIndex;
+      dataSource.splice(dataIndex, 0, newData);
+      var distance = type === "after" ? 1 : 0;
 
-    var state = {
-      row: item,
-      rowIndex: i,
-      expanded: false,
-      level: 0,
-      expandChildrenLength: 0,
-      disabled: table_utils.isRowSelectedDisabled(column, item, i)
-    };
-    state.path = [state];
-    treeDataMap.set(rowValue, state);
-    var children = get.get_1(item, keys.childrenKey);
+      if (state.parent) {
+        var childrenIndex = state.parent.row[keys.childrenKey].findIndex(function (t) {
+          return rowValue === get.get_1(t, keys.rowKey);
+        });
+        state.parent.row[keys.childrenKey].splice(childrenIndex + distance, 0, newData);
+        updateRowExpandLength(this.treeDataMap, state.parent.row, 1, "insert", keys);
+      }
 
-    if (children !== null && children !== void 0 && children.length) {
-      initialTreeDataMap(treeDataMap, children, column, keys);
+      this.treeDataMap.set(newRowValue, newState);
+      updateRowIndex(this.treeDataMap, dataSource, {
+        rowKey: keys.rowKey,
+        minRowIndex: state.rowIndex + 1,
+        type: "add"
+      });
+      return dataSource;
     }
-  }
-}
+  }, {
+    key: "swapData",
+    value: function swapData(dataSource, params, keys) {
+      var startIndex = params.currentIndex;
+      var endIndex = params.targetIndex;
+      if (startIndex === endIndex) return {
+        dataSource: dataSource,
+        result: true
+      };
+      var startRowValue = get.get_1(params.current, keys.rowKey);
+      var endRowValue = get.get_1(params.target, keys.rowKey);
+      var startState = this.treeDataMap.get(startRowValue);
+      var endState = this.treeDataMap.get(endRowValue);
+
+      if (startState.level !== endState.level) {
+        return {
+          dataSource: dataSource,
+          result: false,
+          code: TABLE_TREE_ERROR_CODE_NOT_SAME_LEVEL.code,
+          reason: TABLE_TREE_ERROR_CODE_NOT_SAME_LEVEL.reason
+        };
+      }
+
+      var startLastIndex = startIndex + startState.expandChildrenLength + 1;
+      var endLastIndex = endIndex + endState.expandChildrenLength + 1;
+      var startRowList = dataSource.slice(startIndex, startLastIndex);
+      var endRowList = dataSource.slice(endIndex, endLastIndex);
+
+      if (startIndex > endIndex) {
+        var middleRowList = dataSource.slice(endLastIndex, startIndex);
+        var allSwapList = startRowList.concat(endRowList, middleRowList);
+        dataSource.splice(endIndex, allSwapList.length);
+        dataSource.splice.apply(dataSource, [endIndex, 0].concat(toConsumableArray._toConsumableArray(allSwapList)));
+        updateRowIndex(this.treeDataMap, dataSource, {
+          rowKey: keys.rowKey,
+          minRowIndex: endIndex,
+          maxRowIndex: startLastIndex
+        });
+      } else {
+        var _middleRowList = dataSource.slice(startLastIndex, endIndex);
+
+        var _allSwapList = _middleRowList.concat(endRowList, startRowList);
+
+        dataSource.splice(startIndex, _allSwapList.length);
+        dataSource.splice.apply(dataSource, [startIndex, 0].concat(toConsumableArray._toConsumableArray(_allSwapList)));
+        updateRowIndex(this.treeDataMap, dataSource, {
+          rowKey: keys.rowKey,
+          minRowIndex: startIndex,
+          maxRowIndex: endLastIndex
+        });
+      }
+
+      if (startState.parent) {
+        var children = startState.parent.row[keys.childrenKey];
+        var count = 0;
+        var targetIndex = -1;
+        var currentIndex = -1;
+
+        for (var i = 0, len = children.length; i < len; i++) {
+          if (get.get_1(children[i], keys.rowKey) === startRowValue) {
+            targetIndex = i;
+            count += 1;
+          }
+
+          if (get.get_1(children[i], keys.rowKey) === endRowValue) {
+            currentIndex = i;
+            count += 1;
+          }
+
+          if (count >= 2) break;
+        }
+
+        children[targetIndex] = params.target;
+        children[currentIndex] = params.current;
+      }
+
+      return {
+        dataSource: dataSource,
+        result: true
+      };
+    }
+  }, {
+    key: "expandAll",
+    value: function expandAll(dataSource, keys) {
+      var _this = this;
+
+      this.expandAllRowIndex = 0;
+
+      var expandLoop = function expandLoop(dataSource2, keys2) {
+        var newData = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+        var parentExpanded = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+        var parent = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;
+
+        for (var i = 0, len = dataSource2.length; i < len; i++) {
+          var item = dataSource2[i];
+          var rowValue = get.get_1(item, keys2.rowKey);
+
+          var state = _this.treeDataMap.get(rowValue);
+
+          var children = get.get_1(item, keys2.childrenKey);
+          var originalExpanded = state.expanded;
+          state.rowIndex = _this.expandAllRowIndex;
+          state.expanded = true;
+          state.expandChildrenLength = (children === null || children === void 0 ? void 0 : children.length) || 0;
+          _this.expandAllRowIndex += 1;
+
+          if (!parentExpanded) {
+            newData.push(item);
+          }
+
+          _this.treeDataMap.set(rowValue, state);
+
+          if (children !== null && children !== void 0 && children.length && !originalExpanded) {
+            var tmpParent = parent;
+
+            while ((_tmpParent = tmpParent) !== null && _tmpParent !== void 0 && _tmpParent.row) {
+              var _tmpParent;
+
+              tmpParent.expandChildrenLength += children.length;
+
+              _this.treeDataMap.set(tmpParent.id, tmpParent);
+
+              tmpParent = tmpParent.parent;
+            }
+
+            expandLoop(children, keys2, newData, originalExpanded, state);
+          }
+        }
+
+        return newData;
+      };
+
+      return expandLoop(dataSource, keys);
+    }
+  }, {
+    key: "foldAll",
+    value: function foldAll(dataSource, keys) {
+      var newData = [];
+
+      for (var i = 0, len = dataSource.length; i < len; i++) {
+        var item = dataSource[i];
+        var rowValue = get.get_1(item, keys.rowKey);
+        var state = this.treeDataMap.get(rowValue);
+        state.rowIndex = state.level === 0 ? i : -1;
+        state.expanded = false;
+        state.expandChildrenLength = 0;
+
+        if (state.level === 0) {
+          newData.push(item);
+        }
+
+        var children = get.get_1(item, keys.childrenKey);
+
+        if (children !== null && children !== void 0 && children.length) {
+          this.foldAll(children, keys);
+        }
+      }
+
+      return newData;
+    }
+  }, {
+    key: "getTreeNode",
+    value: function getTreeNode(dataSource, keys) {
+      var treeData = [];
+
+      for (var i = 0, len = dataSource.length; i < len; i++) {
+        var item = dataSource[i];
+        var rowValue = get.get_1(item, keys.rowKey);
+        var state = this.treeDataMap.get(rowValue);
+
+        if (state.level === 0) {
+          treeData.push(item);
+        }
+      }
+
+      return treeData;
+    }
+  }, {
+    key: "initialTreeDataMap",
+    value: function initialTreeDataMap(treeDataMap, dataSource, column, keys) {
+      var level = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0;
+      var parent = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : null;
+
+      for (var i = 0, len = dataSource.length; i < len; i++) {
+        var item = dataSource[i];
+        var rowValue = get.get_1(item, keys.rowKey);
+
+        if (rowValue === void 0) {
+          _common_js_log_log["default"].error("EnhancedTable", "`rowKey` could be wrong, can not get rowValue from `data` by `rowKey`.");
+          return;
+        }
+
+        var children = get.get_1(item, keys.childrenKey);
+        var state = {
+          id: rowValue,
+          row: item,
+          rowIndex: level === 0 ? i : -1,
+          level: level,
+          expanded: false,
+          expandChildrenLength: 0,
+          disabled: table_utils.isRowSelectedDisabled(column, item, i),
+          parent: parent
+        };
+        state.path = parent ? parent.path.concat(state) : [state];
+        treeDataMap.set(rowValue, state);
+
+        if (children !== null && children !== void 0 && children.length) {
+          this.initialTreeDataMap(treeDataMap, children, column, keys, level + 1, state);
+        }
+      }
+    }
+  }, {
+    key: "updateDisabledState",
+    value: function updateDisabledState(dataSource, column, keys) {
+      for (var i = 0, len = dataSource.length; i < len; i++) {
+        var item = dataSource[i];
+        var rowValue = get.get_1(item, keys.rowKey);
+
+        if (rowValue === void 0) {
+          _common_js_log_log["default"].error("EnhancedTable", "`rowKey` could be wrong, can not get rowValue from `data` by `rowKey`.");
+          return;
+        }
+
+        var state = this.treeDataMap.get(rowValue);
+        state.disabled = table_utils.isRowSelectedDisabled(column, item, i);
+        this.treeDataMap.set(rowValue, state);
+        var children = get.get_1(item, keys.childrenKey);
+
+        if (children !== null && children !== void 0 && children.length) {
+          this.updateDisabledState(children, column, keys);
+        }
+      }
+    }
+  }, {
+    key: "validateDataExist",
+    value: function validateDataExist(state, rowValue) {
+      if (!state) {
+        console.warn("TDesign Table Warn: ".concat(rowValue, " does not exist."));
+        return false;
+      }
+
+      return true;
+    }
+  }, {
+    key: "validateDataDoubleExist",
+    value: function validateDataDoubleExist(state, rowValue) {
+      if (state) {
+        console.warn("TDesign Table Warn: Duplicated Key. ".concat(rowValue, " already exists."));
+        return false;
+      }
+
+      return true;
+    }
+  }]);
+
+  return TableTreeStore;
+}();
 function updateRowExpandLength(treeDataMap, row, distance, type, keys) {
   var tmp = row;
 
@@ -287,8 +580,6 @@ function clearRowExpandLength(treeDataMap, row, keys) {
 }
 function updateChildrenRowState(treeDataMap, rowState, expanded, keys) {
   var row = rowState.row,
-      _rowState$level = rowState.level,
-      level = _rowState$level === void 0 ? 0 : _rowState$level,
       rowIndex = rowState.rowIndex;
   var childrenNodes = get.get_1(row, keys.childrenKey);
   childrenNodes.forEach(function (item, kidRowIndex) {
@@ -300,12 +591,9 @@ function updateChildrenRowState(treeDataMap, rowState, expanded, keys) {
       row: item,
       rowIndex: index,
       expanded: false,
-      parent: rowState,
-      level: level + 1,
-      path: []
+      parent: rowState
     });
 
-    newState.path = newState.path.concat(newState);
     treeDataMap.set(rowValue, newState);
 
     if (!expanded) {
@@ -352,9 +640,9 @@ function updateRowIndex(treeDataMap, dataSource, extra) {
   }
 }
 
+exports.TABLE_TREE_ERROR_CODE_NOT_SAME_LEVEL = TABLE_TREE_ERROR_CODE_NOT_SAME_LEVEL;
 exports.clearRowExpandLength = clearRowExpandLength;
 exports["default"] = TableTreeStore;
-exports.initialTreeDataMap = initialTreeDataMap;
 exports.updateChildrenRowState = updateChildrenRowState;
 exports.updateRowData = updateRowData;
 exports.updateRowExpandLength = updateRowExpandLength;