nsc-react-component 2.0.14 → 2.0.17

package/lib/base/tree/TreeSearch.js

@@ -0,0 +1,273 @@
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+import "antd/es/divider/style/css";
+import _Divider from "antd/es/divider";
+import "antd/es/dropdown/style/css";
+import _Dropdown from "antd/es/dropdown";
+import "antd/es/input/style/css";
+import _Input from "antd/es/input";
+import "antd/es/popconfirm/style/css";
+import _Popconfirm from "antd/es/popconfirm";
+import "antd/es/menu/style/css";
+import _Menu from "antd/es/menu";
+import "antd/es/message/style/css";
+import _message from "antd/es/message";
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+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; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+import React, { PureComponent } from "react";
+import { DeleteOutlined, EditOutlined, FolderAddOutlined, PlusOutlined, SyncOutlined } from "@ant-design/icons";
+import NscIcon from "../common/Icon";
+import { request } from "@bj-nsc/msn/lib/utils";
+
+var TreeSearch = /*#__PURE__*/function (_PureComponent) {
+  _inherits(TreeSearch, _PureComponent);
+
+  var _super = _createSuper(TreeSearch);
+
+  function TreeSearch() {
+    var _this2;
+
+    _classCallCheck(this, TreeSearch);
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this2 = _super.call.apply(_super, [this].concat(args));
+
+    _defineProperty(_assertThisInitialized(_this2), "treeRefreshIcon", /*#__PURE__*/React.createRef());
+
+    _defineProperty(_assertThisInitialized(_this2), "selectedTreeNodeId", "");
+
+    _defineProperty(_assertThisInitialized(_this2), "getSelectedNodeId", function () {
+      var selectedNode = _this2.getSelectedNode() || {};
+      return selectedNode.key;
+    });
+
+    _defineProperty(_assertThisInitialized(_this2), "getSelectedNode", function () {
+      return _this2.props.treeInstance.state.selectNode;
+    });
+
+    _defineProperty(_assertThisInitialized(_this2), "handleMenuItemClick", function (e) {
+      var selectedNodeId = _this2.getSelectedNodeId();
+
+      var selectedNode = _this2.getSelectedNode();
+
+      var checkSelectNode = function checkSelectNode() {
+        if (!selectedNodeId) {
+          _message.warn("请选择要修改的目录！");
+
+          return;
+        }
+
+        return true;
+      };
+
+      switch (e.key) {
+        case "add":
+          {
+            _this2.handleAddModule(selectedNode);
+
+            break;
+          }
+
+        case "edit":
+          {
+            if (checkSelectNode()) {
+              _this2.handleEditModule(selectedNode);
+            }
+
+            break;
+          }
+
+        case "delete":
+          {
+            if (checkSelectNode()) {
+              _this2.handleDeleteModule(selectedNode);
+            }
+
+            break;
+          }
+      }
+    });
+
+    _defineProperty(_assertThisInitialized(_this2), "handleAddModule", function (params) {
+      _this2.props.handleAddModule(params);
+    });
+
+    _defineProperty(_assertThisInitialized(_this2), "handleDeleteModule", function (params) {
+      _this2.props.handleDeleteModule(params);
+    });
+
+    _defineProperty(_assertThisInitialized(_this2), "handleMenuSearch", function (e) {
+      _this2.props.treeInstance.handleSearch(e.target.value, {}, "");
+    });
+
+    _defineProperty(_assertThisInitialized(_this2), "handleSearch", function (value, e) {
+      _this2.handleMenuSearch(e);
+    });
+
+    _defineProperty(_assertThisInitialized(_this2), "moduleTreeMenu", /*#__PURE__*/React.createElement(_Menu, {
+      onClick: _this2.handleMenuItemClick
+    }, /*#__PURE__*/React.createElement(_Menu.Item, {
+      key: "add"
+    }, /*#__PURE__*/React.createElement(FolderAddOutlined, {
+      style: {
+        color: "#1890ff"
+      }
+    }), "\u6DFB\u52A0\u76EE\u5F55"), /*#__PURE__*/React.createElement(_Menu.Item, {
+      key: "edit"
+    }, /*#__PURE__*/React.createElement(EditOutlined, {
+      style: {
+        color: "green"
+      }
+    }), "\u7F16\u8F91\u76EE\u5F55"), /*#__PURE__*/React.createElement(_Menu.Item, {
+      key: "remove"
+    }, /*#__PURE__*/React.createElement(_Popconfirm, {
+      title: "\u4F60\u786E\u5B9A\u5220\u9664\u5417?",
+      onConfirm: function onConfirm(e) {
+        if (!_this2.getSelectedNodeId()) {
+          _message.warn("请选择要删除的目录！");
+
+          return;
+        }
+
+        _this2.props.handleDeleteModule(_this2.getSelectedNode()); // this.handleRemoveModule(this.getSelectedNodeId(), "00");
+
+      }
+    }, /*#__PURE__*/React.createElement(DeleteOutlined, {
+      style: {
+        color: "red"
+      }
+    }), "\u5220\u9664\u76EE\u5F55"))));
+
+    _defineProperty(_assertThisInitialized(_this2), "onlyRenderSearch", function () {
+      return /*#__PURE__*/React.createElement("div", {
+        style: {
+          marginBottom: 10
+        }
+      }, /*#__PURE__*/React.createElement(_Input.Search, {
+        allowClear: true,
+        placeholder: "\u641C\u7D22\u76EE\u5F55",
+        onSearch: _this2.handleSearch
+      }));
+    });
+
+    return _this2;
+  }
+
+  _createClass(TreeSearch, [{
+    key: "handleEditModule",
+    value: //修改模块
+    function handleEditModule(params) {
+      this.props.handleEditModule(params); // const _this = this, { moduleEidt } = this.refs;
+      // moduleEidt.show({
+      //   params: pa
+      //   rams,
+      //   type: 'edit',
+      //   callback: function (result) {
+      //     if (!result) return;
+      //     _this.reload(result.type, function () {
+      //       message.success("修改成功！");
+      //     });
+      //   }
+      // });
+    }
+  }, {
+    key: "handleRemoveModule",
+    value:
+    /**
+     *
+     * @param {*} id 要删除的模块ID
+     * @param {*} type  00=目录  01=模块
+     */
+    function handleRemoveModule(id, type, _callback) {
+      if (!id) {
+        console.error("删除主键不能为空，非法操作！");
+        return;
+      }
+
+      var _this = this;
+
+      request("/api/admin/modules/" + id, {
+        method: "DELETE",
+        callback: function callback(data) {
+          if (typeof _callback === "function") _this.props.treeInstance.reload({
+            params: {
+              type: type
+            },
+            callback: _callback
+          });
+        }
+      });
+    }
+    /**
+     * 菜单搜索
+     */
+
+  }, {
+    key: "render",
+    value: function render() {
+      var _this3 = this;
+
+      if (this.props.treeInstance.props.searchable) {
+        return this.onlyRenderSearch();
+      }
+
+      return /*#__PURE__*/React.createElement("div", {
+        style: {
+          marginBottom: 10
+        }
+      }, /*#__PURE__*/React.createElement(_Input, {
+        allowClear: true,
+        addonAfter: /*#__PURE__*/React.createElement("div", null, /*#__PURE__*/React.createElement(_Dropdown, {
+          overlay: this.moduleTreeMenu,
+          trigger: ["click"]
+        }, /*#__PURE__*/React.createElement(PlusOutlined, null)), /*#__PURE__*/React.createElement(_Divider, {
+          type: "vertical"
+        }), /*#__PURE__*/React.createElement(NscIcon, {
+          type: /*#__PURE__*/React.createElement(SyncOutlined, null),
+          ref: this.treeRefreshIcon,
+          onClick: function onClick() {
+            var treeInstance = _this3.props.treeInstance;
+            var treeRefreshIcon = _this3.treeRefreshIcon.current;
+            treeRefreshIcon.setLoading(true);
+            treeInstance.store.reload({
+              callback: function callback() {
+                treeRefreshIcon.setLoading(false);
+              }
+            });
+          }
+        })),
+        placeholder: "\u641C\u7D22\u76EE\u5F55",
+        onPressEnter: this.handleMenuSearch
+      }));
+    }
+  }]);
+
+  return TreeSearch;
+}(PureComponent);
+
+export { TreeSearch as default };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/components/base/tree/TreeSearch.tsx"],"names":["React","PureComponent","DeleteOutlined","EditOutlined","FolderAddOutlined","PlusOutlined","SyncOutlined","NscIcon","request","TreeSearch","createRef","selectedNode","getSelectedNode","key","props","treeInstance","state","selectNode","e","selectedNodeId","getSelectedNodeId","checkSelectNode","warn","handleAddModule","handleEditModule","handleDeleteModule","params","handleSearch","target","value","handleMenuSearch","handleMenuItemClick","color","marginBottom","id","type","callback","console","error","_this","method","data","reload","searchable","onlyRenderSearch","moduleTreeMenu","treeRefreshIcon","current","setLoading","store"],"mappings":"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","sourcesContent":["import React, { PureComponent } from \"react\";\r\nimport { Input, Dropdown, Divider, Menu, Popconfirm, message } from \"antd\";\r\nimport {\r\n  DeleteOutlined,\r\n  EditOutlined,\r\n  FolderAddOutlined,\r\n  PlusOutlined,\r\n  SyncOutlined,\r\n} from \"@ant-design/icons\";\r\nimport NscIcon from \"../common/Icon\";\r\nimport { request } from \"@bj-nsc/msn/lib/utils\";\r\nimport NscTree from \".\";\r\ninterface ITreeSearchProps {\r\n  treeRef?: React.RefObject<any>;\r\n  treeInstance: NscTree;\r\n  handleAddModule?: (params: any) => void;\r\n  handleEditModule?: (params: any) => void;\r\n  handleDeleteModule?: (params: any) => void;\r\n}\r\n\r\nexport default class TreeSearch extends PureComponent<ITreeSearchProps> {\r\n  treeRefreshIcon = React.createRef<NscIcon>();\r\n\r\n  selectedTreeNodeId = \"\";\r\n\r\n  getSelectedNodeId = () => {\r\n    const selectedNode = this.getSelectedNode() || {};\r\n    return selectedNode.key;\r\n  };\r\n\r\n  getSelectedNode = () => {\r\n    return this.props.treeInstance.state.selectNode;\r\n  };\r\n\r\n  /**\r\n   * 模块树操作\r\n   */\r\n  handleMenuItemClick = (e) => {\r\n    const selectedNodeId = this.getSelectedNodeId();\r\n    const selectedNode = this.getSelectedNode();\r\n\r\n    const checkSelectNode = () => {\r\n      if (!selectedNodeId) {\r\n        message.warn(\"请选择要修改的目录！\");\r\n        return;\r\n      }\r\n      return true;\r\n    };\r\n\r\n    switch (e.key) {\r\n      case \"add\": {\r\n        this.handleAddModule(selectedNode);\r\n        break;\r\n      }\r\n      case \"edit\": {\r\n        if (checkSelectNode()) {\r\n          this.handleEditModule(selectedNode);\r\n        }\r\n        break;\r\n      }\r\n      case \"delete\": {\r\n        if (checkSelectNode()) {\r\n          this.handleDeleteModule(selectedNode);\r\n        }\r\n        break;\r\n      }\r\n    }\r\n  };\r\n\r\n  /**\r\n   * 添加模块数据\r\n   * @param {*} params\r\n   */\r\n  handleAddModule = (params) => {\r\n    this.props.handleAddModule(params);\r\n  };\r\n\r\n  //修改模块\r\n  handleEditModule(params) {\r\n    this.props.handleEditModule(params);\r\n    // const _this = this, { moduleEidt } = this.refs;\r\n    // moduleEidt.show({\r\n    //   params: pa\r\n    //   rams,\r\n    //   type: 'edit',\r\n    //   callback: function (result) {\r\n    //     if (!result) return;\r\n    //     _this.reload(result.type, function () {\r\n    //       message.success(\"修改成功！\");\r\n    //     });\r\n    //   }\r\n    // });\r\n  }\r\n\r\n  handleDeleteModule = (params: any) => {\r\n    this.props.handleDeleteModule(params);\r\n  };\r\n\r\n  /**\r\n   *\r\n   * @param {*} id 要删除的模块ID\r\n   * @param {*} type  00=目录  01=模块\r\n   */\r\n  handleRemoveModule(id, type, callback?) {\r\n    if (!id) {\r\n      console.error(\"删除主键不能为空，非法操作！\");\r\n      return;\r\n    }\r\n    const _this = this;\r\n    request(\"/api/admin/modules/\" + id, {\r\n      method: \"DELETE\",\r\n      callback: function (data) {\r\n        if (typeof callback === \"function\")\r\n          _this.props.treeInstance.reload({ params: { type }, callback });\r\n      },\r\n    });\r\n  }\r\n\r\n  /**\r\n   * 菜单搜索\r\n   */\r\n  handleMenuSearch = (e) => {\r\n    this.props.treeInstance.handleSearch(e.target.value, {}, \"\");\r\n  };\r\n\r\n  // 仅搜索\r\n  handleSearch = (value, e) => {\r\n    this.handleMenuSearch(e);\r\n  };\r\n\r\n  //模块树的菜单Menu\r\n  moduleTreeMenu = (\r\n    <Menu onClick={this.handleMenuItemClick}>\r\n      <Menu.Item key=\"add\">\r\n        <FolderAddOutlined style={{ color: \"#1890ff\" }} />\r\n        添加目录\r\n      </Menu.Item>\r\n      <Menu.Item key=\"edit\">\r\n        <EditOutlined style={{ color: \"green\" }} />\r\n        编辑目录\r\n      </Menu.Item>\r\n      <Menu.Item key=\"remove\">\r\n        <Popconfirm\r\n          title=\"你确定删除吗?\"\r\n          onConfirm={(e) => {\r\n            if (!this.getSelectedNodeId()) {\r\n              message.warn(\"请选择要删除的目录！\");\r\n              return;\r\n            }\r\n            this.props.handleDeleteModule(this.getSelectedNode());\r\n            // this.handleRemoveModule(this.getSelectedNodeId(), \"00\");\r\n          }}\r\n        >\r\n          <DeleteOutlined style={{ color: \"red\" }} />\r\n          删除目录\r\n        </Popconfirm>\r\n      </Menu.Item>\r\n    </Menu>\r\n  );\r\n\r\n  onlyRenderSearch = () => {\r\n    return (\r\n      <div style={{ marginBottom: 10 }}>\r\n        <Input.Search\r\n          allowClear\r\n          placeholder=\"搜索目录\"\r\n          onSearch={this.handleSearch}\r\n        ></Input.Search>\r\n      </div>\r\n    );\r\n  };\r\n\r\n  render() {\r\n    if (this.props.treeInstance.props.searchable) {\r\n      return this.onlyRenderSearch();\r\n    }\r\n    return (\r\n      <div style={{ marginBottom: 10 }}>\r\n        <Input\r\n          allowClear\r\n          addonAfter={\r\n            <div>\r\n              <Dropdown overlay={this.moduleTreeMenu} trigger={[\"click\"]}>\r\n                <PlusOutlined />\r\n              </Dropdown>\r\n              <Divider type=\"vertical\" />\r\n              <NscIcon\r\n                type={<SyncOutlined />}\r\n                ref={this.treeRefreshIcon}\r\n                onClick={() => {\r\n                  const { treeInstance } = this.props;\r\n                  const treeRefreshIcon = this.treeRefreshIcon.current;\r\n                  treeRefreshIcon.setLoading(true);\r\n                  treeInstance.store.reload({\r\n                    callback: function () {\r\n                      treeRefreshIcon.setLoading(false);\r\n                    },\r\n                  });\r\n                }}\r\n              />\r\n            </div>\r\n          }\r\n          placeholder=\"搜索目录\"\r\n          onPressEnter={this.handleMenuSearch}\r\n        />\r\n      </div>\r\n    );\r\n  }\r\n}\r\n"]}

package/lib/base/tree/index.js

@@ -0,0 +1,307 @@
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+import "antd/es/spin/style/css";
+import _Spin from "antd/es/spin";
+import "antd/es/tree/style/css";
+import _Tree from "antd/es/tree";
+var _excluded = ["key"],
+    _excluded2 = ["treeData", "openKeys"];
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+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; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+import React from "react";
+import TreePanel from "../common/TreePanel";
+import { utils } from "@bj-nsc/msn/lib/utils";
+export { Store, StoreConfigType } from "@bj-nsc/msn";
+import TreeSearch from "./TreeSearch";
+import styles from "./index.less";
+var TreeNode = _Tree.TreeNode; // import TreeNode from "./NscTreeNode";
+
+var NscTree = /*#__PURE__*/function (_TreePanel) {
+  _inherits(NscTree, _TreePanel);
+
+  var _super = _createSuper(NscTree);
+
+  function NscTree(_props) {
+    var _this2;
+
+    _classCallCheck(this, NscTree);
+
+    _this2 = _super.call(this, _props);
+
+    _defineProperty(_assertThisInitialized(_this2), "nscTreeRef", /*#__PURE__*/React.createRef());
+
+    _defineProperty(_assertThisInitialized(_this2), "handleAddModule", function (node) {
+      var handleAdd = _this2.props.handleAdd;
+      handleAdd && handleAdd(node);
+    });
+
+    _defineProperty(_assertThisInitialized(_this2), "handleEditModule", function (node) {
+      var handleEdit = _this2.props.handleEdit;
+      handleEdit && handleEdit(node);
+    });
+
+    _defineProperty(_assertThisInitialized(_this2), "handleDeleteModule", function (node) {
+      var handleDelete = _this2.props.handleDelete;
+      handleDelete && handleDelete(node);
+    });
+
+    _defineProperty(_assertThisInitialized(_this2), "_onLoadData", function (treeNode) {
+      return new Promise(function (resolve) {
+        var _this = _assertThisInitialized(_this2),
+            node = treeNode.props.dataref;
+
+        _this2.store.lazyLoad(node, function () {
+          resolve(node);
+
+          _this.forceUpdate();
+        });
+      });
+    });
+
+    _defineProperty(_assertThisInitialized(_this2), "renderTreeNodes", function (data, renderFn) {
+      var nodeProps = _this2.props.nodeProps || {};
+
+      var nodeKey = nodeProps.key,
+          restNodeProps = _objectWithoutProperties(nodeProps, _excluded);
+
+      var nodes = data.map(function (item) {
+        console.log("item", item);
+        var props = {
+          dataref: item
+        };
+        item.config.fields.forEach(function (field) {
+          if (field.name === "key" && nodeKey) {
+            props.key = item[nodeKey];
+            item.key = item[nodeKey];
+          } else {
+            props[field.name] = item[field.name];
+          }
+        });
+        Object.assign(props, restNodeProps);
+
+        if (renderFn) {
+          props = utils.callback(renderFn, _assertThisInitialized(_this2), [props, item]);
+        }
+
+        if (item.childNodes) {
+          return /*#__PURE__*/React.createElement(TreeNode, _extends({}, props, {
+            key: item.attribute.key
+          }), _this2.renderTreeNodes(item.childNodes, renderFn));
+        }
+
+        var titleNode = null;
+
+        if (item.attribute.subtitle) {
+          titleNode = /*#__PURE__*/React.createElement("span", null, /*#__PURE__*/React.createElement("span", null, item.title), /*#__PURE__*/React.createElement("span", {
+            style: {
+              color: "rgba(0,0,0,.45)"
+            }
+          }, "\uFF08".concat(item.attribute.subtitle, "\uFF09")));
+        } else {
+          titleNode = /*#__PURE__*/React.createElement("span", null, item.title);
+        }
+
+        return /*#__PURE__*/React.createElement(TreeNode, _extends({}, props, {
+          key: item.attribute.key,
+          title: titleNode
+        }));
+      });
+      return nodes;
+    });
+
+    _this2.renderTemplate = _this2.renderTemplate.bind(_assertThisInitialized(_this2));
+    return _this2;
+  }
+
+  _createClass(NscTree, [{
+    key: "_dataToCheckedKeys",
+    value: function _dataToCheckedKeys(modelData) {
+      var checkedKeys = {
+        checked: [],
+        halfChecked: []
+      };
+      utils.forEachTree(modelData, function (node) {
+        if (node.checked == true) {
+          checkedKeys.checked.push(node.attribute.key);
+        }
+      });
+      return checkedKeys;
+    }
+    /**
+     * 树搜索
+     */
+    // handleSearch = (value) => {
+    //   this.setState({ searchText: value });
+    // };
+
+    /**
+     * 获取选中节点ID数组
+     * @return String[]
+     */
+
+  }, {
+    key: "getCheckedKeys",
+    value: function getCheckedKeys() {
+      var checkedKeys = this.nscTreeRef.current.checkedKeys;
+      return checkedKeys;
+    }
+    /**
+     * 获取选中节点对象数组
+     * @return node[]
+     */
+
+  }, {
+    key: "getCheckedNodes",
+    value: function getCheckedNodes() {
+      var _this$nscTreeRef$curr = this.nscTreeRef.current.state,
+          checkedKeys = _this$nscTreeRef$curr.checkedKeys,
+          keyEntities = _this$nscTreeRef$curr.keyEntities;
+      var nodes = [];
+      checkedKeys.map(function (key) {
+        // nodes.push(keyEntities[key].node.props.dataref);
+        var node = keyEntities[key].node;
+        nodes.push(node.props.dataref);
+      });
+      return nodes;
+    }
+    /**
+     * 获取全部选中节点ID，包含半选中节点ID
+     * @return String[]
+     */
+
+  }, {
+    key: "getCheckedAllKeys",
+    value: function getCheckedAllKeys() {
+      var _this$nscTreeRef$curr2 = this.nscTreeRef.current.state,
+          checkedKeys = _this$nscTreeRef$curr2.checkedKeys,
+          halfCheckedKeys = _this$nscTreeRef$curr2.halfCheckedKeys;
+      return checkedKeys.concat(halfCheckedKeys);
+    }
+    /**
+     * 获取全部选中节点Node对象，包含半选中节点Node对象
+     * @return node[]
+     */
+
+  }, {
+    key: "getCheckedAllNodes",
+    value: function getCheckedAllNodes() {
+      var _this$nscTreeRef$curr3 = this.nscTreeRef.current.state,
+          checkedKeys = _this$nscTreeRef$curr3.checkedKeys,
+          halfCheckedKeys = _this$nscTreeRef$curr3.halfCheckedKeys,
+          keyEntities = _this$nscTreeRef$curr3.keyEntities;
+      var checkedKeysAll = checkedKeys.concat(halfCheckedKeys);
+      var nodes = [];
+      checkedKeysAll.map(function (key) {
+        var node = keyEntities[key].node;
+        nodes.push(node.props.dataref);
+      });
+      return nodes;
+    } // 添加模块
+
+  }, {
+    key: "renderTemplate",
+    value: function renderTemplate() {
+      var _this3 = this;
+
+      var treeProps = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      var newMenuDatas = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+
+      var treeData = treeProps.treeData,
+          openKeys = treeProps.openKeys,
+          props = _objectWithoutProperties(treeProps, _excluded2);
+
+      var _this = this;
+
+      if (props.checkPropagation) {
+        props.checkStrictly = true;
+      }
+
+      if (props.showIcon == null) {
+        props.showIcon = true;
+      }
+
+      var lazyload = this.store.config.lazyload;
+
+      if (lazyload) {
+        props.loadData = this._onLoadData;
+      }
+
+      var onCheckFn = props.onCheck;
+
+      props.onCheck = function (checkedKeys, e) {
+        _this.setState({
+          checkedKeys: checkedKeys
+        });
+
+        utils.callback(onCheckFn, _this, [checkedKeys, e]);
+      };
+
+      var onSelectFn = props.onSelect;
+
+      props.onSelect = function (selectedKeys, nodeInfo) {
+        utils.callback(onSelectFn, _this, [selectedKeys, nodeInfo]);
+
+        _this3.setState({
+          selectNode: nodeInfo.selected ? nodeInfo.selectedNodes[0] : null,
+          selectedKeys: selectedKeys
+        });
+      };
+
+      if (openKeys) {
+        props.expandedKeys = openKeys;
+      } else {
+        delete props.expandedKeys;
+      }
+
+      return /*#__PURE__*/React.createElement(_Spin, {
+        spinning: this.state.loading
+      }, /*#__PURE__*/React.createElement("div", {
+        className: styles["nsc-tree-box"]
+      }, (_this.props.editable || _this.props.searchable) && /*#__PURE__*/React.createElement(TreeSearch, {
+        treeInstance: this,
+        handleAddModule: this.handleAddModule,
+        handleEditModule: this.handleEditModule,
+        handleDeleteModule: this.handleDeleteModule
+      }), Array.isArray(newMenuDatas) && newMenuDatas.length > 0 && /*#__PURE__*/React.createElement(_Tree, _extends({
+        ref: this.nscTreeRef,
+        checkable: true
+      }, props), this.renderTreeNodes(newMenuDatas, props.renderTreeNode))));
+    }
+  }]);
+
+  return NscTree;
+}(TreePanel);
+
+_defineProperty(NscTree, "defaultProps", {
+  store: {}
+});
+
+export default NscTree;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/components/base/tree/index.tsx"],"names":["React","TreePanel","utils","Store","StoreConfigType","TreeSearch","styles","TreeNode","NscTree","props","createRef","node","handleAdd","handleEdit","handleDelete","treeNode","Promise","resolve","_this","dataref","store","lazyLoad","forceUpdate","data","renderFn","nodeProps","nodeKey","key","restNodeProps","nodes","map","item","console","log","config","fields","forEach","field","name","Object","assign","callback","childNodes","attribute","renderTreeNodes","titleNode","subtitle","title","color","renderTemplate","bind","modelData","checkedKeys","checked","halfChecked","forEachTree","push","nscTreeRef","current","state","keyEntities","halfCheckedKeys","concat","checkedKeysAll","treeProps","newMenuDatas","treeData","openKeys","checkPropagation","checkStrictly","showIcon","lazyload","loadData","_onLoadData","onCheckFn","onCheck","e","setState","onSelectFn","onSelect","selectedKeys","nodeInfo","selectNode","selected","selectedNodes","expandedKeys","loading","editable","searchable","handleAddModule","handleEditModule","handleDeleteModule","Array","isArray","length","renderTreeNode"],"mappings":"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","sourcesContent":["import React from \"react\";\r\nimport { Tree, TreeProps, Spin, TreeNodeProps } from \"antd\";\r\nimport TreePanel, {\r\n  ITreePanelProps,\r\n  TreeCommonProps,\r\n} from \"../common/TreePanel\";\r\nimport { utils } from \"@bj-nsc/msn/lib/utils\";\r\nimport RcTree from \"rc-tree\";\r\nimport { DataNode, EventDataNode } from \"rc-tree/lib/interface\";\r\nexport { Store, StoreConfigType } from \"@bj-nsc/msn\";\r\nimport TreeSearch from \"./TreeSearch\";\r\nimport styles from \"./index.less\";\r\nconst { TreeNode } = Tree;\r\n// import TreeNode from \"./NscTreeNode\";\r\ntype NscDataNodeProps = DataNode & { props: { dataref: any } };\r\n\r\nexport interface NscTreeProps extends ITreePanelProps {\r\n  editable?: boolean;\r\n  treeData?: any[];\r\n  searchable?: boolean;\r\n  nodeProps?: TreeNodeProps;\r\n}\r\n\r\nclass NscTree extends TreePanel<NscTreeProps & TreeCommonProps> {\r\n  nscTreeRef = React.createRef<RcTree & TreeProps>();\r\n\r\n  constructor(props) {\r\n    super(props);\r\n    this.renderTemplate = this.renderTemplate.bind(this);\r\n  }\r\n\r\n  static defaultProps: { store: {} } = { store: {} };\r\n\r\n  _dataToCheckedKeys(modelData): any {\r\n    let checkedKeys = { checked: [], halfChecked: [] };\r\n    utils.forEachTree(modelData, function (node) {\r\n      if (node.checked == true) {\r\n        checkedKeys.checked.push(node.attribute.key);\r\n      }\r\n    });\r\n    return checkedKeys;\r\n  }\r\n\r\n  /**\r\n   * 树搜索\r\n   */\r\n  // handleSearch = (value) => {\r\n  //   this.setState({ searchText: value });\r\n  // };\r\n\r\n  /**\r\n   * 获取选中节点ID数组\r\n   * @return String[]\r\n   */\r\n  getCheckedKeys() {\r\n    const { checkedKeys } = this.nscTreeRef.current;\r\n    return checkedKeys;\r\n  }\r\n\r\n  /**\r\n   * 获取选中节点对象数组\r\n   * @return node[]\r\n   */\r\n  getCheckedNodes() {\r\n    const { checkedKeys, keyEntities } = this.nscTreeRef.current.state;\r\n    let nodes = [] as NscDataNodeProps[];\r\n    checkedKeys.map((key) => {\r\n      // nodes.push(keyEntities[key].node.props.dataref);\r\n      const node = keyEntities[key].node as NscDataNodeProps;\r\n      nodes.push(node.props.dataref);\r\n    });\r\n    return nodes;\r\n  }\r\n\r\n  /**\r\n   * 获取全部选中节点ID，包含半选中节点ID\r\n   * @return String[]\r\n   */\r\n  getCheckedAllKeys() {\r\n    const { checkedKeys, halfCheckedKeys } = this.nscTreeRef.current.state;\r\n    return checkedKeys.concat(halfCheckedKeys);\r\n  }\r\n\r\n  /**\r\n   * 获取全部选中节点Node对象，包含半选中节点Node对象\r\n   * @return node[]\r\n   */\r\n  getCheckedAllNodes() {\r\n    const { checkedKeys, halfCheckedKeys, keyEntities } =\r\n      this.nscTreeRef.current.state;\r\n    let checkedKeysAll = checkedKeys.concat(halfCheckedKeys);\r\n    let nodes = [];\r\n    checkedKeysAll.map((key) => {\r\n      const node = keyEntities[key].node as NscDataNodeProps;\r\n      nodes.push(node.props.dataref);\r\n    });\r\n    return nodes;\r\n  }\r\n\r\n  // 添加模块\r\n  handleAddModule = (node) => {\r\n    const handleAdd = this.props.handleAdd;\r\n    handleAdd && handleAdd(node);\r\n  };\r\n\r\n  handleEditModule = (node) => {\r\n    const handleEdit = this.props.handleEdit;\r\n    handleEdit && handleEdit(node);\r\n  };\r\n\r\n  handleDeleteModule = (node) => {\r\n    const handleDelete = this.props.handleDelete;\r\n    handleDelete && handleDelete(node);\r\n  };\r\n\r\n  _onLoadData = (treeNode: EventDataNode & { props: { dataref } }) =>\r\n    new Promise<void>((resolve) => {\r\n      const _this = this,\r\n        node = treeNode.props.dataref;\r\n      this.store.lazyLoad(node, function () {\r\n        resolve(node);\r\n        _this.forceUpdate();\r\n      });\r\n    });\r\n\r\n  renderTemplate(treeProps = {} as ITreePanelProps, newMenuDatas = []) {\r\n    const { treeData, openKeys, ...props } = treeProps;\r\n    const _this = this;\r\n    if (props.checkPropagation) {\r\n      props.checkStrictly = true;\r\n    }\r\n    if (props.showIcon == null) {\r\n      props.showIcon = true;\r\n    }\r\n\r\n    let { lazyload } = this.store.config;\r\n    if (lazyload) {\r\n      props.loadData = this._onLoadData;\r\n    }\r\n    const onCheckFn = props.onCheck;\r\n    props.onCheck = function (checkedKeys, e) {\r\n      _this.setState({ checkedKeys: checkedKeys });\r\n      utils.callback(onCheckFn, _this, [checkedKeys, e]);\r\n    };\r\n    const onSelectFn = props.onSelect;\r\n    props.onSelect = (selectedKeys, nodeInfo) => {\r\n      utils.callback(onSelectFn, _this, [selectedKeys, nodeInfo]);\r\n      this.setState({\r\n        selectNode: nodeInfo.selected ? nodeInfo.selectedNodes[0] : null,\r\n        selectedKeys,\r\n      });\r\n    };\r\n\r\n    if (openKeys) {\r\n      props.expandedKeys = openKeys;\r\n    } else {\r\n      delete props.expandedKeys;\r\n    }\r\n    return (\r\n      <Spin spinning={this.state.loading}>\r\n        <div className={styles[\"nsc-tree-box\"]}>\r\n          {(_this.props.editable || _this.props.searchable) && (\r\n            <TreeSearch\r\n              treeInstance={this}\r\n              handleAddModule={this.handleAddModule}\r\n              handleEditModule={this.handleEditModule}\r\n              handleDeleteModule={this.handleDeleteModule}\r\n            />\r\n          )}\r\n          {Array.isArray(newMenuDatas) && newMenuDatas.length > 0 && (\r\n            <Tree ref={this.nscTreeRef} checkable {...props}>\r\n              {this.renderTreeNodes(newMenuDatas, props.renderTreeNode)}\r\n            </Tree>\r\n          )}\r\n        </div>\r\n      </Spin>\r\n    );\r\n  }\r\n\r\n  renderTreeNodes = (data, renderFn) => {\r\n    const nodeProps = this.props.nodeProps || {};\r\n    const { key: nodeKey, ...restNodeProps } = nodeProps;\r\n    const nodes = data.map((item) => {\r\n      console.log(\"item\", item);\r\n      let props = { dataref: item } as TreeNodeProps;\r\n      item.config.fields.forEach((field) => {\r\n        if (field.name === \"key\" && nodeKey) {\r\n          props.key = item[nodeKey];\r\n          item.key = item[nodeKey];\r\n        } else {\r\n          props[field.name] = item[field.name];\r\n        }\r\n      });\r\n      Object.assign(props, restNodeProps);\r\n      if (renderFn) {\r\n        props = utils.callback(renderFn, this, [props, item]);\r\n      }\r\n\r\n      if (item.childNodes) {\r\n        return (\r\n          <TreeNode {...props} key={item.attribute.key}>\r\n            {this.renderTreeNodes(item.childNodes, renderFn)}\r\n          </TreeNode>\r\n        );\r\n      }\r\n      let titleNode = null;\r\n      if (item.attribute.subtitle) {\r\n        titleNode = (\r\n          <span>\r\n            <span>{item.title}</span>\r\n            <span\r\n              style={{ color: \"rgba(0,0,0,.45)\" }}\r\n            >{`（${item.attribute.subtitle}）`}</span>\r\n          </span>\r\n        );\r\n      } else {\r\n        titleNode = <span>{item.title}</span>;\r\n      }\r\n      return <TreeNode {...props} key={item.attribute.key} title={titleNode} />;\r\n    });\r\n\r\n    return nodes;\r\n  };\r\n}\r\n\r\nexport default NscTree;\r\n"]}

package/lib/{typography → base/typography}/index.js

@@ -47,4 +47,4 @@ var NscTypography = /*#__PURE__*/function (_React$PureComponent) {
 }(React.PureComponent);
 
 export { NscTypography as default };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb21wb25lbnRzL3R5cG9ncmFwaHkvaW5kZXgudHN4Il0sIm5hbWVzIjpbIlJlYWN0IiwiTnNjVHlwb2dyYXBoeSIsInByb3BzIiwiUHVyZUNvbXBvbmVudCJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLE9BQU8sS0FBS0EsS0FBWixNQUF1QixPQUF2Qjs7SUFHcUJDLGE7Ozs7Ozs7Ozs7Ozs7V0FJbkIsa0JBQTBCO0FBQ3hCLDBCQUFPLGlDQUFnQixLQUFLQyxLQUFyQixDQUFQO0FBQ0Q7Ozs7RUFOd0NGLEtBQUssQ0FBQ0csYTs7U0FBNUJGLGEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyBSZWFjdCBmcm9tIFwicmVhY3RcIjtcclxuaW1wb3J0IHsgVHlwb2dyYXBoeSwgVHlwb2dyYXBoeVByb3BzIH0gZnJvbSBcImFudGRcIjtcclxuXHJcbmV4cG9ydCBkZWZhdWx0IGNsYXNzIE5zY1R5cG9ncmFwaHkgZXh0ZW5kcyBSZWFjdC5QdXJlQ29tcG9uZW50PFxyXG4gIFR5cG9ncmFwaHlQcm9wcyxcclxuICBhbnlcclxuPiB7XHJcbiAgcmVuZGVyKCk6IFJlYWN0LlJlYWN0Tm9kZSB7XHJcbiAgICByZXR1cm4gPFR5cG9ncmFwaHkgey4uLnRoaXMucHJvcHN9IC8+O1xyXG4gIH1cclxufVxyXG4iXX0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb21wb25lbnRzL2Jhc2UvdHlwb2dyYXBoeS9pbmRleC50c3giXSwibmFtZXMiOlsiUmVhY3QiLCJOc2NUeXBvZ3JhcGh5IiwicHJvcHMiLCJQdXJlQ29tcG9uZW50Il0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsT0FBTyxLQUFLQSxLQUFaLE1BQXVCLE9BQXZCOztJQUdxQkMsYTs7Ozs7Ozs7Ozs7OztXQUluQixrQkFBMEI7QUFDeEIsMEJBQU8saUNBQWdCLEtBQUtDLEtBQXJCLENBQVA7QUFDRDs7OztFQU53Q0YsS0FBSyxDQUFDRyxhOztTQUE1QkYsYSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIFJlYWN0IGZyb20gXCJyZWFjdFwiO1xyXG5pbXBvcnQgeyBUeXBvZ3JhcGh5LCBUeXBvZ3JhcGh5UHJvcHMgfSBmcm9tIFwiYW50ZFwiO1xyXG5cclxuZXhwb3J0IGRlZmF1bHQgY2xhc3MgTnNjVHlwb2dyYXBoeSBleHRlbmRzIFJlYWN0LlB1cmVDb21wb25lbnQ8XHJcbiAgVHlwb2dyYXBoeVByb3BzLFxyXG4gIGFueVxyXG4+IHtcclxuICByZW5kZXIoKTogUmVhY3QuUmVhY3ROb2RlIHtcclxuICAgIHJldHVybiA8VHlwb2dyYXBoeSB7Li4udGhpcy5wcm9wc30gLz47XHJcbiAgfVxyXG59XHJcbiJdfQ==