@kdcloudjs/table 1.0.0

package/lib/table/pivot/cross-table/cross-table.js

@@ -0,0 +1,71 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/extends"));
+
+var _getOwnPropertySymbols = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/get-own-property-symbols"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _base = require("../../base");
+
+var _buildCrossTable2 = _interopRequireDefault(require("./buildCrossTable"));
+
+var _constants = require("./constants");
+
+var __rest = void 0 && (void 0).__rest || function (s, e) {
+  var t = {};
+
+  for (var p in s) {
+    if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  }
+
+  if (s != null && typeof _getOwnPropertySymbols.default === "function") for (var i = 0, p = (0, _getOwnPropertySymbols.default)(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+
+var CrossTable = function CrossTable(_a) {
+  var _a$BaseTableComponent = _a.BaseTableComponent,
+      BaseTableComponent = _a$BaseTableComponent === void 0 ? _base.Table : _a$BaseTableComponent,
+      leftTree = _a.leftTree,
+      leftTotalNode = _a.leftTotalNode,
+      topTree = _a.topTree,
+      topTotalNode = _a.topTotalNode,
+      getValue = _a.getValue,
+      getCellProps = _a.getCellProps,
+      leftMetaColumns = _a.leftMetaColumns,
+      render = _a.render,
+      baseTableRef = _a.baseTableRef,
+      others = __rest(_a, ["BaseTableComponent", "leftTree", "leftTotalNode", "topTree", "topTotalNode", "getValue", "getCellProps", "leftMetaColumns", "render", "baseTableRef"]);
+
+  var _buildCrossTable = (0, _buildCrossTable2.default)({
+    leftTree: leftTree,
+    topTree: topTree,
+    leftTotalNode: leftTotalNode,
+    topTotalNode: topTotalNode,
+    getValue: getValue,
+    getCellProps: getCellProps,
+    render: render,
+    leftMetaColumns: leftMetaColumns
+  }),
+      dataSource = _buildCrossTable.dataSource,
+      columns = _buildCrossTable.columns;
+
+  return /*#__PURE__*/_react.default.createElement(BaseTableComponent, (0, _extends2.default)({
+    ref: baseTableRef
+  }, others, {
+    primaryKey: _constants.ROW_KEY,
+    dataSource: dataSource,
+    columns: columns
+  }));
+};
+
+exports.default = CrossTable;

package/lib/table/pivot/cross-table/index.d.ts

@@ -0,0 +1,4 @@
+export { default as CrossTable, CrossTableProps } from './cross-table';
+export { default as buildCrossTable, BuildCrossTableOptions } from './buildCrossTable';
+export { ROW_KEY } from './constants';
+export { CrossTreeNode, CrossTableLeftMetaColumn, LeftCrossTreeNode, TopCrossTreeNode, CrossTableIndicator, } from './interfaces';

package/lib/table/pivot/cross-table/index.js

@@ -0,0 +1,31 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "CrossTable", {
+  enumerable: true,
+  get: function get() {
+    return _crossTable.default;
+  }
+});
+Object.defineProperty(exports, "buildCrossTable", {
+  enumerable: true,
+  get: function get() {
+    return _buildCrossTable.default;
+  }
+});
+Object.defineProperty(exports, "ROW_KEY", {
+  enumerable: true,
+  get: function get() {
+    return _constants.ROW_KEY;
+  }
+});
+
+var _crossTable = _interopRequireDefault(require("./cross-table"));
+
+var _buildCrossTable = _interopRequireDefault(require("./buildCrossTable"));
+
+var _constants = require("./constants");

package/lib/table/pivot/cross-table/interfaces.d.ts

@@ -0,0 +1,29 @@
+import { ReactNode } from 'react';
+import { ArtColumnStaticPart, CellProps } from '../../interfaces';
+export interface CrossTableIndicator extends ArtColumnStaticPart {
+    code: string;
+    expression?: string;
+}
+export interface CrossTableLeftMetaColumn extends Omit<ArtColumnStaticPart, 'hidden'> {
+    /** 自定义渲染方法 */
+    render?(leftNode: LeftCrossTreeNode, leftDepth: number): ReactNode;
+    /** 自定义的获取单元格 props 的方法 */
+    getCellProps?(leftNode: LeftCrossTreeNode, leftDepth: number): CellProps;
+}
+export interface CrossTreeNode {
+    key: string;
+    value: string;
+    title?: ReactNode;
+    data?: any;
+    hidden?: boolean;
+    children?: CrossTreeNode[];
+}
+/** 交叉表左侧树状结构的树节点 */
+export interface LeftCrossTreeNode extends CrossTreeNode {
+    children?: CrossTreeNode[];
+}
+/** 交叉表上方树状结构的树节点
+ * 列的名称现由 value 字段提供，故从 ArtColumnStaticPart 移除了 name 字段 */
+export interface TopCrossTreeNode extends CrossTreeNode, Omit<ArtColumnStaticPart, 'name'> {
+    children?: TopCrossTreeNode[];
+}

package/lib/table/pivot/cross-table/internals.d.ts

@@ -0,0 +1,13 @@
+import { ArtColumn } from '../../interfaces';
+export interface CrossTableLeftColumn extends ArtColumn {
+    columnType: 'left';
+    children?: never;
+}
+export interface CrossTableDataColumn extends ArtColumn {
+    columnType: 'data';
+}
+export interface CrossTableDataParentColumn extends ArtColumn {
+    columnType: 'data-parent';
+    children: (CrossTableDataParentColumn | CrossTableDataColumn)[];
+}
+export declare type CrossTableRenderColumn = CrossTableLeftColumn | CrossTableDataColumn | CrossTableDataParentColumn;

package/lib/table/pivot/cross-tree-table/buildCrossTreeTable.d.ts

@@ -0,0 +1,14 @@
+import { TableProps } from '../../base';
+import { BuildCrossTableOptions, CrossTableLeftMetaColumn } from '../cross-table';
+export declare type BuildCrossTreeTableOptions = Omit<BuildCrossTableOptions, 'leftMetaColumns' | 'leftTotalNode' | 'topTotalNode'> & {
+    primaryColumn: CrossTableLeftMetaColumn;
+    openKeys: string[];
+    onChangeOpenKeys(nextOpenKeys: string[]): void;
+    indentSize?: number;
+    isLeafNode?(node: any, nodeMeta: {
+        depth: number;
+        expanded: boolean;
+        rowKey: string;
+    }): boolean;
+};
+export default function buildCrossTreeTable(options: BuildCrossTreeTableOptions): Pick<TableProps, 'columns' | 'dataSource'>;

package/lib/table/pivot/cross-tree-table/buildCrossTreeTable.js

@@ -0,0 +1,240 @@
+"use strict";
+
+var _sliceInstanceProperty = require("@babel/runtime-corejs3/core-js-stable/instance/slice");
+
+var _Array$from = require("@babel/runtime-corejs3/core-js-stable/array/from");
+
+var _Symbol = require("@babel/runtime-corejs3/core-js-stable/symbol");
+
+var _getIteratorMethod = require("@babel/runtime-corejs3/core-js/get-iterator-method");
+
+var _getIterator = require("@babel/runtime-corejs3/core-js/get-iterator");
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = buildCrossTreeTable;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/defineProperty"));
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/extends"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/toConsumableArray"));
+
+var _getOwnPropertySymbols = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/get-own-property-symbols"));
+
+var _concat = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/concat"));
+
+var _rxjs = require("rxjs");
+
+var _pipeline = require("../../pipeline");
+
+var _utils = require("../../utils");
+
+var _crossTable = require("../cross-table");
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof _Symbol === "undefined" || _getIteratorMethod(o) == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = _getIterator(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { var _context4; if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = _sliceInstanceProperty(_context4 = Object.prototype.toString.call(o)).call(_context4, 8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return _Array$from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+var __rest = void 0 && (void 0).__rest || function (s, e) {
+  var t = {};
+
+  for (var p in s) {
+    if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  }
+
+  if (s != null && typeof _getOwnPropertySymbols.default === "function") for (var i = 0, p = (0, _getOwnPropertySymbols.default)(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+
+function buildCrossTreeTable(options) {
+  var _a, _b;
+
+  var primaryColumn = options.primaryColumn,
+      openKeys = options.openKeys,
+      onChangeOpenKeys = options.onChangeOpenKeys,
+      indentSize = options.indentSize,
+      _options$isLeafNode = options.isLeafNode,
+      isLeafNodeOpt = _options$isLeafNode === void 0 ? _utils.isLeafNode : _options$isLeafNode; // 有的时候 leftTree/topTree 是通过 node.children 传入的
+  // 此时 leftTree/topTree 等于 null 和等于空数组是等价的
+  // 故在这里兼容 leftTree/topTree 为空的情况
+
+  var leftTree = (_a = options.leftTree) !== null && _a !== void 0 ? _a : [];
+  var topTree = (_b = options.topTree) !== null && _b !== void 0 ? _b : [];
+  var pipeline = new _pipeline.TablePipeline({
+    state: {},
+    setState: _rxjs.noop,
+    ctx: {
+      primaryKey: _crossTable.ROW_KEY
+    }
+  });
+  pipeline.input({
+    dataSource: getDataSource(),
+    columns: getColumns()
+  });
+  pipeline.use(_pipeline.features.treeMode({
+    openKeys: openKeys,
+    onChangeOpenKeys: onChangeOpenKeys,
+    indentSize: indentSize,
+    isLeafNode: function isLeafNode(row, nodeMeta) {
+      // 调用上层 isLeafNodeOpt 时，会从 row.node 中读取该表格行对应的 leftTreeNode
+      return isLeafNodeOpt(row.node, nodeMeta);
+    }
+  }));
+  return {
+    dataSource: pipeline.getDataSource(),
+    columns: pipeline.getColumns()
+  };
+  /** 获取表格的列配置 */
+
+  function getColumns() {
+    var _context;
+
+    return (0, _concat.default)(_context = [(0, _extends2.default)((0, _extends2.default)({}, primaryColumn), {
+      getValue: function getValue(row) {
+        return row.node.value;
+      },
+      getCellProps: function getCellProps(value, row) {
+        if (primaryColumn.getCellProps) {
+          return primaryColumn.getCellProps(row.node, row.nodes.length - 1);
+        }
+      },
+      render: function render(value, row) {
+        if (primaryColumn.render) {
+          return primaryColumn.render(row.node, row.nodes.length - 1);
+        }
+
+        return value;
+      }
+    })]).call(_context, (0, _toConsumableArray2.default)(getDataPartColumns()));
+    /** 获取表格数据部分的列配置 */
+
+    function getDataPartColumns() {
+      return dfs(topTree, {
+        depth: 0
+      });
+
+      function dfs(nodes, ctx) {
+        var result = [];
+
+        var _iterator = _createForOfIteratorHelper(nodes),
+            _step;
+
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var node = _step.value;
+
+            if ((0, _utils.isLeafNode)(node)) {
+              result.push(getDataColumn(node, ctx.depth));
+            } else {
+              var key = node.key,
+                  value = node.value,
+                  children = node.children,
+                  others = __rest(node, ["key", "value", "children"]);
+
+              result.push((0, _extends2.default)((0, _extends2.default)({}, others), {
+                name: value,
+                children: dfs(children, {
+                  depth: ctx.depth + 1
+                })
+              }));
+            }
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+
+        return result;
+      }
+    }
+
+    function getDataColumn(topNode, topDepth) {
+      var columnGetValue = function columnGetValue(row) {
+        var leftDepth = row.nodes.length - 1;
+        var leftNode = row.node;
+        return options.getValue(leftNode, topNode, leftDepth, topDepth);
+      };
+
+      var key = topNode.key,
+          value = topNode.value,
+          children = topNode.children,
+          others = __rest(topNode, ["key", "value", "children"]);
+
+      return (0, _extends2.default)((0, _extends2.default)({}, others), {
+        getValue: columnGetValue,
+        name: value,
+        children: null,
+        render: function render(value, row) {
+          if (options.render) {
+            var leftDepth = row.nodes.length - 1;
+            var leftNode = row.node;
+            return options.render(value, leftNode, topNode, leftDepth, topDepth);
+          }
+
+          return value;
+        },
+        getCellProps: function getCellProps(value, row) {
+          if (options.getCellProps) {
+            var leftDepth = row.nodes.length - 1;
+            var leftNode = row.node;
+            return options.getCellProps(value, leftNode, topNode, leftDepth, topDepth);
+          }
+        }
+      });
+    }
+  }
+
+  function getDataSource() {
+    return dfs(leftTree, {
+      nodes: []
+    });
+
+    function dfs(nodes, ctx) {
+      var result = [];
+
+      var _iterator2 = _createForOfIteratorHelper(nodes),
+          _step2;
+
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var node = _step2.value;
+
+          if (node.hidden) {
+            // 跳过被隐藏的节点
+            continue;
+          }
+
+          if ((0, _utils.isLeafNode)(node)) {
+            var _context2, _result$push;
+
+            result.push((_result$push = {}, (0, _defineProperty2.default)(_result$push, _crossTable.ROW_KEY, node.key), (0, _defineProperty2.default)(_result$push, "node", node), (0, _defineProperty2.default)(_result$push, "nodes", (0, _concat.default)(_context2 = []).call(_context2, (0, _toConsumableArray2.default)(ctx.nodes), [node])), _result$push));
+          } else {
+            var _context3, _result$push2;
+
+            var _nodes = (0, _concat.default)(_context3 = []).call(_context3, (0, _toConsumableArray2.default)(ctx.nodes), [node]);
+
+            ctx.nodes.push(node);
+            var children = dfs(node.children, ctx);
+            result.push((_result$push2 = {}, (0, _defineProperty2.default)(_result$push2, _crossTable.ROW_KEY, node.key), (0, _defineProperty2.default)(_result$push2, "node", node), (0, _defineProperty2.default)(_result$push2, "nodes", _nodes), (0, _defineProperty2.default)(_result$push2, "children", children), _result$push2));
+            ctx.nodes.pop();
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+
+      return result;
+    }
+  }
+}

package/lib/table/pivot/cross-tree-table/cross-tree-table.d.ts

@@ -0,0 +1,38 @@
+import React from 'react';
+import { noop } from 'rxjs';
+import { Table, TableProps } from '../../base';
+import { CellProps } from '../../interfaces';
+import { CrossTableLeftMetaColumn, LeftCrossTreeNode, TopCrossTreeNode } from '../cross-table';
+export interface CrossTreeTableProps extends Omit<TableProps, 'dataSource' | 'columns' | 'primaryKey'> {
+    BaseTableComponent?: any;
+    baseTableRef?: React.Ref<Table>;
+    primaryColumn: CrossTableLeftMetaColumn;
+    leftTree: LeftCrossTreeNode[];
+    topTree: TopCrossTreeNode[];
+    defaultOpenKeys?: string[];
+    openKeys?: string[];
+    onChangeOpenKeys?(nextOpenKeys: string[]): void;
+    indentSize?: number;
+    isLeafNode?(node: any, nodeMeta: {
+        depth: number;
+        expanded: boolean;
+        rowKey: string;
+    }): boolean;
+    getValue(leftNode: LeftCrossTreeNode, topNode: TopCrossTreeNode, leftDepth: number, topDepth: number): any;
+    render?(value: any, leftNode: LeftCrossTreeNode, topNode: TopCrossTreeNode, leftDepth: number, topDepth: number): React.ReactNode;
+    getCellProps?(value: any, leftNode: LeftCrossTreeNode, topNode: TopCrossTreeNode, leftDepth: number, topDepth: number): CellProps;
+}
+export default class CrossTreeTable extends React.Component<CrossTreeTableProps, {
+    openKeys: string[];
+}> {
+    static defaultProps: {
+        defaultOpenKeys: string[];
+        onChangeOpenKeys: typeof noop;
+    };
+    static getDerivedStateFromProps(nextProps: Readonly<CrossTreeTableProps>): {
+        openKeys: string[];
+    };
+    constructor(props: Readonly<CrossTreeTableProps>);
+    onChangeOpenKeys: (nextOpenKeys: string[]) => void;
+    render(): JSX.Element;
+}

package/lib/table/pivot/cross-tree-table/cross-tree-table.js

@@ -0,0 +1,144 @@
+"use strict";
+
+var _Reflect$construct = require("@babel/runtime-corejs3/core-js-stable/reflect/construct");
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/extends"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/createClass"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/getPrototypeOf"));
+
+var _getOwnPropertySymbols = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/get-own-property-symbols"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _rxjs = require("rxjs");
+
+var _base = require("../../base");
+
+var _crossTable = require("../cross-table");
+
+var _buildCrossTreeTable2 = _interopRequireDefault(require("./buildCrossTreeTable"));
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = _Reflect$construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !_Reflect$construct) return false; if (_Reflect$construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(_Reflect$construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var __rest = void 0 && (void 0).__rest || function (s, e) {
+  var t = {};
+
+  for (var p in s) {
+    if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  }
+
+  if (s != null && typeof _getOwnPropertySymbols.default === "function") for (var i = 0, p = (0, _getOwnPropertySymbols.default)(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+
+var CrossTreeTable = /*#__PURE__*/function (_React$Component) {
+  (0, _inherits2.default)(CrossTreeTable, _React$Component);
+
+  var _super = _createSuper(CrossTreeTable);
+
+  function CrossTreeTable(props) {
+    var _this;
+
+    (0, _classCallCheck2.default)(this, CrossTreeTable);
+    _this = _super.call(this, props);
+
+    _this.onChangeOpenKeys = function (nextOpenKeys) {
+      _this.props.onChangeOpenKeys(nextOpenKeys);
+
+      if (!('openKeys' in _this.props)) {
+        _this.setState({
+          openKeys: nextOpenKeys
+        });
+      }
+    };
+
+    _this.state = {
+      openKeys: props.defaultOpenKeys
+    };
+    return _this;
+  }
+
+  (0, _createClass2.default)(CrossTreeTable, [{
+    key: "render",
+    value: function render() {
+      var _a = this.props,
+          _a$BaseTableComponent = _a.BaseTableComponent,
+          BaseTableComponent = _a$BaseTableComponent === void 0 ? _base.Table : _a$BaseTableComponent,
+          leftTree = _a.leftTree,
+          topTree = _a.topTree,
+          getValue = _a.getValue,
+          getCellProps = _a.getCellProps,
+          primaryColumn = _a.primaryColumn,
+          render = _a.render,
+          openKeysProp = _a.openKeys,
+          defaultOpenKeys = _a.defaultOpenKeys,
+          onChangeOpenKeys = _a.onChangeOpenKeys,
+          indentSize = _a.indentSize,
+          isLeafNode = _a.isLeafNode,
+          baseTableRef = _a.baseTableRef,
+          others = __rest(_a, ["BaseTableComponent", "leftTree", "topTree", "getValue", "getCellProps", "primaryColumn", "render", "openKeys", "defaultOpenKeys", "onChangeOpenKeys", "indentSize", "isLeafNode", "baseTableRef"]);
+
+      var openKeys = openKeysProp !== null && openKeysProp !== void 0 ? openKeysProp : this.state.openKeys;
+
+      var _buildCrossTreeTable = (0, _buildCrossTreeTable2.default)({
+        leftTree: leftTree,
+        topTree: topTree,
+        getValue: getValue,
+        getCellProps: getCellProps,
+        render: render,
+        primaryColumn: primaryColumn,
+        openKeys: openKeys,
+        onChangeOpenKeys: this.onChangeOpenKeys,
+        indentSize: indentSize,
+        isLeafNode: isLeafNode
+      }),
+          dataSource = _buildCrossTreeTable.dataSource,
+          columns = _buildCrossTreeTable.columns;
+
+      return /*#__PURE__*/_react.default.createElement(BaseTableComponent, (0, _extends2.default)({
+        ref: baseTableRef
+      }, others, {
+        primaryKey: _crossTable.ROW_KEY,
+        dataSource: dataSource,
+        columns: columns
+      }));
+    }
+  }], [{
+    key: "getDerivedStateFromProps",
+    value: function getDerivedStateFromProps(nextProps) {
+      if ('openKeys' in nextProps) {
+        return {
+          openKeys: nextProps.openKeys
+        };
+      }
+
+      return null;
+    }
+  }]);
+  return CrossTreeTable;
+}(_react.default.Component);
+
+exports.default = CrossTreeTable;
+CrossTreeTable.defaultProps = {
+  defaultOpenKeys: [],
+  onChangeOpenKeys: _rxjs.noop
+};

package/lib/table/pivot/cross-tree-table/index.d.ts

@@ -0,0 +1,2 @@
+export { default as CrossTreeTable, CrossTreeTableProps } from './cross-tree-table';
+export { default as buildCrossTreeTable, BuildCrossTreeTableOptions } from './buildCrossTreeTable';

package/lib/table/pivot/cross-tree-table/index.js

@@ -0,0 +1,23 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "CrossTreeTable", {
+  enumerable: true,
+  get: function get() {
+    return _crossTreeTable.default;
+  }
+});
+Object.defineProperty(exports, "buildCrossTreeTable", {
+  enumerable: true,
+  get: function get() {
+    return _buildCrossTreeTable.default;
+  }
+});
+
+var _crossTreeTable = _interopRequireDefault(require("./cross-tree-table"));
+
+var _buildCrossTreeTable = _interopRequireDefault(require("./buildCrossTreeTable"));

package/lib/table/pivot/pivot-utils/buildDrillTree.d.ts

@@ -0,0 +1,16 @@
+import { DrillNode } from './interfaces';
+export interface BuildDrillTreeOptions<T extends DrillNode> {
+    /** 是否生成顶层的「总计」节点，默认不生成 */
+    includeTopWrapper?: boolean;
+    /** 生成顶层节点时，顶层节点内的文本值，默认为「总计」 */
+    totalValue?: string;
+    /** 自定义的编码函数，用于根据下钻的值序列生成唯一的字符串.
+     * 该参数留空 表示使用默认的编码方式 */
+    encode?(path: string[]): string;
+    /** 判断一个节点是否展开，没有展开的节点将不进行下钻 */
+    isExpand?(key: string): boolean;
+    /** 是否强制展开总计节点，默认为 true */
+    enforceExpandTotalNode?: boolean;
+}
+/** 根据指定的 code 序列计算下钻树 */
+export default function buildDrillTree(data: any[], codes: string[], { encode, totalValue, includeTopWrapper, isExpand, enforceExpandTotalNode, }?: BuildDrillTreeOptions<DrillNode>): DrillNode[];