fan-standard-comp 3.1.10 → 3.2.0

package/lib/utils/dictSelectUtil.js

@@ -0,0 +1,161 @@
+"use strict";
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.filterDictText = filterDictText;
+exports.filterMultiDictText = filterMultiDictText;
+exports.transformDictValue = transformDictValue;
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { 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 = it.call(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) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(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; }
+/**
+ * 字典 取值数据
+ * author: shomychen
+ * date: 2022.12.30
+ */
+
+/**
+ * 字典值替换文本通用方法
+ * @param {Array} dictOptions  字典数组
+ * @param {String} text  字典值(多个可以用,隔开）
+ * @param {Object} optionName  指定字段值（默认 { value: 'value', label: 'label' }）
+ *
+ * @return String
+ */
+function filterDictText(dictOptions, text) {
+  var optionName = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
+    value: 'value',
+    label: 'label'
+  };
+  // -- 字典翻译 text 允许逗号分隔 ---
+  var dictOptionName = optionName || {
+    value: 'value',
+    label: 'label'
+  };
+  if (text != null && Array.isArray(dictOptions)) {
+    var result = [];
+    // 允许多个逗号分隔，允许传数组对象
+    var splitText;
+    if (Array.isArray(text)) {
+      splitText = text;
+    } else {
+      splitText = text.toString().trim().split(',');
+    }
+    var _iterator = _createForOfIteratorHelper(splitText),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var txt = _step.value;
+        var dictText = txt;
+        var _iterator2 = _createForOfIteratorHelper(dictOptions),
+          _step2;
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var dictItem = _step2.value;
+            if (txt.toString() === dictItem[dictOptionName.value || 'value'].toString()) {
+              dictText = dictItem[dictOptionName.label || 'label'] || dictItem.text || dictItem.title;
+              break;
+            }
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+        result.push(dictText);
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    return result.join(',');
+  }
+  return text;
+  // -- 字典翻译 text 允许逗号分隔 ---
+}
+
+/**
+ * 字典值替换文本通用方法(多选)
+ * @param {Array}  dictOptions  字典数组
+ * @param {String, Array} text  字典值(多个可以用,隔开或者是数组格式）
+ * @param {Object} optionName  指定字段值（默认 { value: 'value', label: 'label' }）
+ *
+ * @return String
+ */
+
+function filterMultiDictText(dictOptions, text) {
+  var optionName = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
+    value: 'value',
+    label: 'label'
+  };
+  // js “!text” 认为0为空，所以做提前处理
+  var dictOptionName = optionName || {
+    value: 'value',
+    label: 'label'
+  };
+  if (text === 0 || text === '0') {
+    if (dictOptions) {
+      var _iterator3 = _createForOfIteratorHelper(dictOptions),
+        _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var dictItem = _step3.value;
+          if (text == dictItem[dictOptionName.value || 'value']) {
+            return dictItem[dictOptionName.label || 'label'] || dictItem.text || dictItem.title;
+          }
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+    }
+  }
+  if (!text || text == 'null' || !dictOptions || dictOptions.length == 0) {
+    return "";
+  }
+  var re = "";
+  text = text.toString();
+  var arr = text.split(",");
+  dictOptions.forEach(function (option) {
+    if (option) {
+      for (var i = 0; i < arr.length; i++) {
+        if (arr[i] === option[dictOptionName.value || 'value']) {
+          re += (option[dictOptionName.label || 'label'] || option.text || option.title) + ",";
+          break;
+        }
+      }
+    }
+  });
+  if (re == "") {
+    return text;
+  }
+  return re.substring(0, re.length - 1);
+}
+
+/**
+ * 转换数据字典value为整型
+ * @param {Array} dictOptions  字典数组
+ *
+ * @return Array
+ * */
+
+function transformDictValue(dictOptions) {
+  if (Array.isArray(dictOptions)) {
+    return dictOptions.map(function (option) {
+      return _objectSpread(_objectSpread({}, option), {}, {
+        value: Number(option.value)
+      });
+    });
+  } else {
+    return dictOptions;
+  }
+}

package/lib/utils/filterPermission.js

@@ -3,104 +3,84 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.btnClickFunc = exports.btnIsDisabled = exports.btnIsHide = exports.removeNoPermission = void 0;
-
+exports.removeNoPermission = exports.btnIsHide = exports.btnIsDisabled = exports.btnClickFunc = void 0;
 var _lodash = _interopRequireDefault(require("lodash"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-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; }
-
-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); }
-
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
 // 按钮方法
 var btnClickFunc = function btnClickFunc(fn) {
   var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   if (!fn) return null;
   var paramsArr = [];
-
   if (_typeof(params) === 'object') {
     Object.keys(params).map(function (item) {
       paramsArr.push(params[item]);
     });
   }
-
   if (typeof fn === 'function') {
     return fn.apply(void 0, paramsArr); // 表格列返回的是方法
   }
 
   return fn;
-}; // 按钮是否禁用
-
-
+};
+// 按钮是否禁用
 exports.btnClickFunc = btnClickFunc;
-
 var btnIsDisabled = function btnIsDisabled(isDisabled) {
   var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   if (!isDisabled) return false;
   var paramsArr = [];
-
   if (_typeof(params) === 'object') {
     Object.keys(params).map(function (item) {
       paramsArr.push(params[item]);
     });
   }
-
   if (typeof isDisabled === 'function') {
     return isDisabled.apply(void 0, paramsArr); // 表格列返回的是方法
   }
 
   return isDisabled;
-}; // 按钮是否隐藏
-
-
+};
+// 按钮是否隐藏
 exports.btnIsDisabled = btnIsDisabled;
-
 var btnIsHide = function btnIsHide(isHide) {
   var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   if (!isHide) return false;
   var paramsArr = [];
-
   if (_typeof(params) === 'object') {
     Object.keys(params).map(function (item) {
       paramsArr.push(params[item]);
     });
   }
-
   if (typeof isHide === 'function') {
     return isHide.apply(void 0, paramsArr); // 表格列返回的是方法
   }
 
   return isHide;
-}; // 重新组合数据(排除不包含在permissionCodes内及isHide数据
-
-
+};
+// 重新组合数据(排除不包含在permissionCodes内及isHide数据
 exports.btnIsHide = btnIsHide;
-
 var removeNoPermission = function removeNoPermission(array, permissionCodes, codes, params) {
   return Array.isArray(array) && array.filter(function (item) {
     if (item.children) {
       item.children = removeNoPermission(item.children, permissionCodes, codes, params);
       if (item.children.length === 0) return false; // 如果子集合过滤为空时，不返当前数据
-    } // permissionCodes未定义，则直接返回不进行过滤
-
-
+    }
+    // permissionCodes未定义，则直接返回不进行过滤
     if (item.hasOwnProperty('code') && permissionCodes) {
       // if (!permissionCodes) return true //  permissionCodes未定义，则直接返回不进行过滤
       // 判断是否包含 'code'字段，如果包含则先过滤有在 permissionCodes内的(permissionCodes数组为0时，也不返回数据)
       // 并用是不隐藏的条件
       return permissionCodes.length !== 0 && permissionCodes.includes(item.code) && !btnIsHide(item.isHide, params);
     }
-
     if (item.hasOwnProperty('isHide')) {
       // 判断是否包含 'isHide'字段，如果包含则先过滤 isHide 为false
       return !btnIsHide(item.isHide, params);
     }
-
     return true;
   }).map(function (resultItem) {
     // 与codes进行对比，相应的 code匹配以对应的name,icon,code返回
@@ -109,19 +89,15 @@ var removeNoPermission = function removeNoPermission(array, permissionCodes, cod
       var matchIndex = _lodash.default.findIndex(codes, function (btnItem) {
         return btnItem.code === resultItem.code;
       });
-
       if (matchIndex !== -1) {
         var _codes$matchIndex;
-
         // 如果有配置code，则使用func.code.js里面配置的名称
         resultItem = _objectSpread(_objectSpread(_objectSpread({}, resultItem), codes[matchIndex]), {}, {
           icon: resultItem.icon || ((_codes$matchIndex = codes[matchIndex]) === null || _codes$matchIndex === void 0 ? void 0 : _codes$matchIndex.icon)
         });
       }
     }
-
     return resultItem;
   });
 };
-
 exports.removeNoPermission = removeNoPermission;

package/lib/utils/getParentNodes.js

@@ -3,8 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getNodePaths = exports.getChildrenNodes = exports.getParentNodes = void 0;
-
+exports.getParentNodes = exports.getNodePaths = exports.getChildrenNodes = void 0;
 /**
  * @description  递归查看父级节点数据集合及当前节点数据
  * @params {Array}  list 当前需要过滤查看的数据集合、
@@ -27,42 +26,34 @@ var getParentNodes = function getParentNodes(list, nodeKey) {
   // const childrenParams = ['menuItems', 'menuFuncItems', 'items']
   var matchNode = [];
   var parentKeys = []; // 存储查找到的节点的父节点数据
-
   var nodeParent = []; // 存储查找到的节点的父节点数据
   // 移除上一次累加的数据
-
   var removePrevIndex = function removePrevIndex(array, item) {
     for (var i = 0; i < array.length; i += 1) {
       if (array[i][params.keyParam] === item[params.keyParam]) {
         return i;
       }
     }
-
     return null;
   };
-
   var deepFind = function deepFind(array, nodeId) {
     for (var i = 0; i < array.length; i += 1) {
       var node = array[i];
-
       if (node[params.keyParam] === nodeId) {
         matchNode.splice(0, 1, node); // 查找到则赋值，且跳出循环
-
         break;
-      } // 如果是单个
-
-
+      }
+      // 如果是单个
       if (node[params.childrenParam] && node[params.childrenParam].length > 0) {
         deepFind(node[params.childrenParam] || node[params.childrenParam], nodeId);
         nodeParent.push(node); // 将当前节点数据存储到父节点数据中
-
         if (matchNode.length > 0) {
           break; // 在子节点查找到了，需要跳出
         } else {
           nodeParent.splice(removePrevIndex(nodeParent, node), 1); // 如果在子节点没有查找到，则将原来添加的父节点数据移除
         }
-      } // 其他条件
-
+      }
+      // 其他条件
       /* else if (node.menuFuncItems && node.menuFuncItems.length > 0) {
         deepFind(node.menuFuncItems, nodeId);
         nodeParent.push(node); // 将当前节点数据存储到父节点数据中
@@ -90,33 +81,27 @@ var getParentNodes = function getParentNodes(list, nodeKey) {
           nodeParent.splice(removePrevIndex(nodeParent, node), 1); // 如果在子节点没有查找到，则将原来添加的父节点数据移除
         }
       }*/
-
     }
 
     return matchNode; // 返回查找到的节点数据（格式为数组）
-  }; // 查找单个节点
-
+  };
 
+  // 查找单个节点
   var findMatchItem = function findMatchItem(arrList, key) {
     var matchItem;
-
     for (var i = 0; i < arrList.length; i += 1) {
       var node = arrList[i];
-
       if (node[params.keyParam] === key) {
         matchItem = node;
         break;
       }
-
       if (node[params.childrenParam]) {
         matchItem = findMatchItem(node[params.childrenParam], key);
       }
     }
-
     return matchItem;
-  }; // nodeKey 为数组时返回当前数据（TODO。目前仅返回一级，多级情况未判断，且 nodeParent 值也未调整）
-
-
+  };
+  // nodeKey 为数组时返回当前数据（TODO。目前仅返回一级，多级情况未判断，且 nodeParent 值也未调整）
   if (Array.isArray(nodeKey)) {
     // const {showCheckedStrategy} = extraProps;
     // TODO 需要判断 showCheckedStrategy 值为 SHOW_PARENT、 SHOW_CHILD 、SHOW_ALL不同情况展示
@@ -127,31 +112,30 @@ var getParentNodes = function getParentNodes(list, nodeKey) {
   } else {
     deepFind(list, nodeKey);
   }
-
   nodeParent.forEach(function (par) {
     return parentKeys.push(par[params.keyParam]);
   }); // 将所有父节点的关键值（keyParam指定字段名）的数据集合在数组内
-
   return {
     nodeParent: nodeParent,
     parentKeys: parentKeys,
     matchNode: matchNode
   }; // 最终查找到的父节点数组 // nodeParent.concat(result || []);
 };
+
 /**
- * @description  递归查找指定ID所有的子菜单与子功能集合
+ * @description  递归查找树的所有节点及id
  * @params {Array}  childNode 当前需要过滤查看的数据集合、
  * @params {Object} params 指定当前数据中，筛选对应子集合字段名及匹配标识值字段名
- *                         （childrenParam：指当前子集合数据字段名（字符串表示单个，数组表示当前多个子集合字段名），keyParam： 指当前匹配标识值字段名）
- * @params {Object} extra
+ *    @value { String } childrenParam：指当前子集合数据字段名（字符串表示单个，数组表示当前多个子集合字段名）
+ *    @value { String } keyParam： 指当前匹配标识值字段名）
  *
  * @result {Array} childKeys  所有子项的id
- * @result {Array} nodeChildren   当前传入nodeKey值所在的数据对象集合
+ * @result {Array} nodeChildren   所有节点数据对象集合
+ *
+ * @usage：
+ * getChildrenNodes(childNode, params)
  * */
-
-
 exports.getParentNodes = getParentNodes;
-
 var getChildrenNodes = function getChildrenNodes(childNode) {
   var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
     childrenParam: 'children',
@@ -159,7 +143,6 @@ var getChildrenNodes = function getChildrenNodes(childNode) {
   };
   var childKeys = [];
   var nodeChildren = []; // 存储：authId, types
-
   var deepFindChild = function deepFindChild(cList) {
     Array.isArray(cList) && cList.forEach(function (item) {
       childKeys.push(item[params.keyParam]);
@@ -167,51 +150,45 @@ var getChildrenNodes = function getChildrenNodes(childNode) {
       if (item[params.childrenParam]) deepFindChild(item[params.childrenParam]);
     });
   };
-
   deepFindChild(childNode);
   return {
     childKeys: childKeys,
     nodeChildren: nodeChildren
   };
-}; // 查找节点路径
-
+};
 
+// 查找节点路径
 exports.getChildrenNodes = getChildrenNodes;
-
 var getNodePaths = function getNodePaths(list, nodeKey) {
   var params = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
     childrenParam: 'children',
     keyParam: 'value'
   };
   var extraProps = arguments.length > 3 ? arguments[3] : undefined;
-
   // 获取指定节点的路径数组
   var getPathByKey = function getPathByKey(value, arr) {
     var findNodePath = function findNodePath(node, value, nodePathArray) {
       // 这里可以自定义push的内容，而不是整个node,而且这里node也包含了children
-      nodePathArray.push(node); // 找到符合条件的节点，通过throw终止掉递归
-
+      nodePathArray.push(node);
+      // 找到符合条件的节点，通过throw终止掉递归
       if (node[params.keyParam] === value) {
         // 也可以直接使用return;结束循环
         throw "over!";
       }
-
       if (node[params.childrenParam] && node[params.childrenParam].length > 0) {
         for (var i = 0; i < node[params.childrenParam].length; i++) {
           findNodePath(node[params.childrenParam][i], value, nodePathArray);
-        } // 当前节点的子节点遍历完依旧没找到，则删除路径中的该节点
-
-
+        }
+        // 当前节点的子节点遍历完依旧没找到，则删除路径中的该节点
         nodePathArray.pop();
       } else {
         // 找到叶子节点时，删除路径当中的该叶子节点
         nodePathArray.pop();
       }
-    }; // 用于存储节点唯一标识值路径数组
-
+    };
 
+    // 用于存储节点唯一标识值路径数组
     var nodePathArray = [];
-
     try {
       for (var i = 0; i < arr.length; i++) {
         findNodePath(arr[i], value, nodePathArray);
@@ -220,17 +197,13 @@ var getNodePaths = function getNodePaths(list, nodeKey) {
       return nodePathArray;
     }
   };
-
   var pathNode = [];
-
   if (Array.isArray(nodeKey)) {
     nodeKey.map(function (key) {
       var pathItems = getPathByKey(key, list);
       if (pathItems) pathNode.push(pathItems);
     });
   }
-
   return pathNode;
 };
-
 exports.getNodePaths = getNodePaths;

package/lib/utils/index.js

@@ -3,18 +3,18 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+var _exportNames = {
+  UtilValueFormat: true,
+  getParentNodes: true,
+  getChildrenNodes: true,
+  getNodePaths: true
+};
 Object.defineProperty(exports, "UtilValueFormat", {
   enumerable: true,
   get: function get() {
     return _ValueFormat.default;
   }
 });
-Object.defineProperty(exports, "getParentNodes", {
-  enumerable: true,
-  get: function get() {
-    return _getParentNodes.getParentNodes;
-  }
-});
 Object.defineProperty(exports, "getChildrenNodes", {
   enumerable: true,
   get: function get() {
@@ -27,9 +27,24 @@ Object.defineProperty(exports, "getNodePaths", {
     return _getParentNodes.getNodePaths;
   }
 });
-
+Object.defineProperty(exports, "getParentNodes", {
+  enumerable: true,
+  get: function get() {
+    return _getParentNodes.getParentNodes;
+  }
+});
 var _ValueFormat = _interopRequireDefault(require("./ValueFormat"));
-
 var _getParentNodes = require("./getParentNodes");
-
+var _dictSelectUtil = require("./dictSelectUtil");
+Object.keys(_dictSelectUtil).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _dictSelectUtil[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _dictSelectUtil[key];
+    }
+  });
+});
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fan-standard-comp",
-  "version": "3.1.10",
+  "version": "3.2.0",
   "description": "FZ standard-comp,basic of antd4.0 and custom component.",
   "main": "lib/index.js",
   "module": "es/index.js",
@@ -26,22 +26,23 @@
   "devDependencies": {
     "@ant-design/icons": "^4.3.0",
     "@types/classnames": "^2.2.11",
-    "antd": "4.24.11",
+    "antd": "4.24.12",
     "babel-loader": "^8.2.2",
     "babel-plugin-import": "^1.13.3",
     "classnames": "^2.2.6",
     "dumi": "1.1.20",
-    "father-build": "^1.19.1",
+    "father-build": "^1.22.5",
     "lodash": "^4.17.15",
     "react": "^16.11.0",
     "react-dom": "^16.11.0",
     "webpack-cli": "4.3.1"
   },
   "dependencies": {
-    "ant-design-draggable-modal": "^1.0.0",
     "css-loader": "3.6.0",
     "file-loader": "6.2.0",
+    "gulp-typescript": "5.0.1",
     "less-loader": "5.0.0",
+    "react-uid": "^2.3.3",
     "style-loader": "1.3.0",
     "webpack": "4.44.1"
   }