@cgeui/utils 0.0.2 → 0.0.4

package/dist/lib/charts/index.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _utils = require("./Chart/utils");
+Object.keys(_utils).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _utils[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _utils[key];
+    }
+  });
+});
+var _chartTheme = require("./chartTheme");
+Object.keys(_chartTheme).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _chartTheme[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _chartTheme[key];
+    }
+  });
+});
+var _utils2 = require("./utils");
+Object.keys(_utils2).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _utils2[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _utils2[key];
+    }
+  });
+});
+var _config = require("./SuperChart/config");
+Object.keys(_config).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _config[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _config[key];
+    }
+  });
+});
+var _util = require("./PieChart/util");
+Object.keys(_util).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _util[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _util[key];
+    }
+  });
+});

package/dist/lib/charts/utils/charts/hex2Rgb.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hex2Rgb = hex2Rgb;
+/**
+ * 将十六进制颜色值转换为RGB格式，并可指定透明度
+ * @param hex 十六进制颜色值，可以是三位或六位
+ * @param opacity 透明度，取值范围0-1
+ * @returns 转换后的RGB颜色值，包含透明度
+ */
+function hex2Rgb(hex, opacity) {
+  // 定义rgb数组
+  var rgb = [];
+  var resolvedHex = hex;
+  // 判断传入是否为#三位十六进制数
+  if (/^\#[0-9A-F]{3}$/i.test(resolvedHex)) {
+    // 把三位十六进制数转化为六位,将每个字符重复两次
+    var sixHex = resolvedHex.replace(/[0-9A-F]/gi, function (kw) {
+      return kw + kw;
+    });
+    resolvedHex = sixHex;
+  }
+  // 判断传入是否为#六位十六进制数
+  if (/^#[0-9A-F]{6}$/i.test(resolvedHex)) {
+    // 十六进制转化为十进制并存入数组
+    resolvedHex.replace(/[0-9A-F]{2}/gi, function (kw) {
+      rgb.push(parseInt('0x' + kw, 16));
+    });
+
+    // 输出RGB格式颜色
+    return "rgb(".concat(rgb.join(','), ")").slice(0, "rgb(".concat(rgb.join(','), ")").length - 1) + ',' + opacity + ')';
+  } else {
+    // 对非六位的十六进制颜色值，直接返回并追加透明度
+    return resolvedHex.slice(0, resolvedHex.length - 1) + ',' + opacity + ')';
+  }
+}

package/dist/lib/charts/utils/constants/env.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var ENV = {
+  namespace: 'catlnas',
+  defaultPage: '/',
+  loginPath: '/user/login'
+};
+var _default = exports.default = ENV;

package/dist/lib/charts/utils/constants/helper.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ALARM_LEVEL_MAP = void 0;
+var ALARM_LEVEL_MAP = exports.ALARM_LEVEL_MAP = {
+  L1: '提示',
+  L2: '一般',
+  L3: '严重'
+};

package/dist/lib/charts/utils/constants/index.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _env = require("./env");
+Object.keys(_env).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _env[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _env[key];
+    }
+  });
+});
+var _helper = require("./helper");
+Object.keys(_helper).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _helper[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _helper[key];
+    }
+  });
+});
+var _table = require("./table");
+Object.keys(_table).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _table[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _table[key];
+    }
+  });
+});

package/dist/lib/charts/utils/constants/table.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.OPERATIONS = void 0;
+var OPERATIONS = exports.OPERATIONS = {
+  lookUp: {
+    name: 'lookUp',
+    action: {
+      targetName: 'catlnas'
+    },
+    // TODO 国际化
+    text: '查看详情'
+  },
+  export: {
+    name: 'export',
+    action: {
+      targetName: 'catlnas'
+    },
+    text: 'component.operation.export'
+  }
+};

package/dist/lib/charts/utils/data.js

@@ -0,0 +1,454 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.smartMergeIntervals = exports.mergeObjValueWithKey = exports.mergeIntervalsByNum = exports.mergeIntervalObj = exports.mergeIntervalList = exports.mergeInterval = exports.mergeBoundaryIntervals = exports.mapToArr = exports.isNumeric = exports.getTreeNodeTitle = exports.getRangeParams = exports.getIntervals = exports.getCompleteData = exports.getBoundaryMergeStartAndEnd = exports.getBoundaryContinuation = exports.dealTreeData = exports.accMod = exports.accAdd = void 0;
+var _lodash = require("lodash");
+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); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+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; }
+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(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } /* eslint-disable @typescript-eslint/no-unused-expressions */
+// 告警/预警中心补齐数据的方法
+var getCompleteData = exports.getCompleteData = function getCompleteData(data, key, completeArr) {
+  var groupData = (0, _lodash.groupBy)(data, key);
+  var _loop = function _loop(item) {
+    var _groupData$item;
+    if (((_groupData$item = groupData[item]) === null || _groupData$item === void 0 ? void 0 : _groupData$item.length) < (completeArr === null || completeArr === void 0 ? void 0 : completeArr.length)) {
+      groupData[item] = completeArr.map(function (l) {
+        return groupData[item].find(function (d) {
+          return d.group === l;
+        }) || {
+          name: item,
+          value: 0,
+          group: l
+        };
+      });
+    }
+  };
+  for (var item in groupData) {
+    _loop(item);
+  }
+  return (0, _lodash.flatten)((0, _lodash.values)(groupData));
+};
+var isNumeric = exports.isNumeric = function isNumeric(value) {
+  return /^\d+$/.test(value);
+};
+var dealTreeData = exports.dealTreeData = function dealTreeData(treeData) {
+  return treeData.map(function (item) {
+    return _objectSpread(_objectSpread({}, item), {}, {
+      title: item === null || item === void 0 ? void 0 : item.name,
+      key: item === null || item === void 0 ? void 0 : item.id,
+      value: item === null || item === void 0 ? void 0 : item.id,
+      children: item !== null && item !== void 0 && item.children && item !== null && item !== void 0 && item.children.length ? dealTreeData(item === null || item === void 0 ? void 0 : item.children) : []
+    });
+  });
+};
+var getTreeNodeTitle = exports.getTreeNodeTitle = function getTreeNodeTitle(node, nodeKey) {
+  var nodeTitle = "";
+  node.forEach(function (_ref) {
+    var children = _ref.children,
+      key = _ref.key,
+      title = _ref.title;
+    if (key === nodeKey) {
+      nodeTitle = title;
+    } else {
+      (children === null || children === void 0 ? void 0 : children.length) && getTreeNodeTitle(children, nodeKey);
+    }
+  });
+  return nodeTitle;
+};
+var getIntervals = exports.getIntervals = function getIntervals(value) {
+  return /(\(|\[)\s*(\d+)?\D*,\s*(\d+)?\D*(\)|\])/.exec(value);
+};
+
+/**
+ * 将两个对象按字段相加
+ * @param obj1
+ * @param obj2
+ * @param keys
+ * @returns 合并后的对象
+ */
+var mergeObjValueWithKey = exports.mergeObjValueWithKey = function mergeObjValueWithKey(obj1, obj2, keys) {
+  var obj = {};
+  keys.forEach(function (key) {
+    console.log(key, obj1[key], obj2[key]);
+    obj[key] = Number(obj1[key]) + Number(obj2[key]);
+  });
+  return obj;
+};
+
+/**
+ * 将两个连续的开闭区间合并
+ * @param inter1
+ * @param inter2
+ * @returns 合并后的区间
+ */
+var mergeInterval = exports.mergeInterval = function mergeInterval(inter1, inter2) {
+  var _getIntervals;
+  var end = ((_getIntervals = getIntervals(inter2)) === null || _getIntervals === void 0 ? void 0 : _getIntervals[3]) || "";
+  console.log(inter1, inter2);
+  return inter1.replace(/(\(|\[)\s*(\d+)?\D*,\s*(\d+)?\D*(\)|\])/, function () {
+    for (var _len = arguments.length, arg = new Array(_len), _key = 0; _key < _len; _key++) {
+      arg[_key] = arguments[_key];
+    }
+    console.log(arg, end);
+    return "".concat(arg[1]).concat(arg[2] || "", ",").concat(end).concat(arg[4] || "");
+  });
+};
+
+/**
+ * 合并两个连续的区间对象
+ * @param obj1
+ * @param obj2
+ * @param keys
+ */
+var mergeIntervalObj = exports.mergeIntervalObj = function mergeIntervalObj(obj1, obj2, keys) {
+  var interval = mergeInterval(obj1[keys[0]], obj2[keys[0]]);
+  return _objectSpread(_defineProperty({}, keys[0], interval), mergeObjValueWithKey(obj1, obj2, keys.slice(1)));
+};
+
+/**
+ * 合并区间，不会判断连续，返回第一元素的开始，和最后元素的结束
+ * @param fields 要合并的字段列表，第一个为区间字段
+ * @param list 要合并的数组区间
+ * */
+var mergeIntervalList = exports.mergeIntervalList = function mergeIntervalList(list, fields) {
+  return list.reduce(function (prev, cur) {
+    var v = mergeIntervalObj(prev, cur, fields);
+    console.log("mergeIntervalObj", prev, cur, v);
+    return mergeIntervalObj(prev, cur, fields);
+  });
+};
+
+/**
+ * 将list区间按一定的数量来合并，不足的部分不合并
+ * @param list
+ * @param fields
+ * @param num
+ * @param start
+ * @param end 合并结束的位置，end不合并
+ * @returns
+ */
+var mergeIntervalsByNum = exports.mergeIntervalsByNum = function mergeIntervalsByNum(list, fields) {
+  var num = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 2;
+  var start = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+  var end = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0;
+  var _end = end || list.length;
+  var startList = list.slice(0, start);
+  var mergeList = list.slice(start, _end);
+  var endList = list.slice(_end);
+  var _list = [];
+  for (var i = 0; i < Math.floor(mergeList.length / num); i++) {
+    var arr = mergeList.slice(num * i, num * (i + 1));
+    var mergeObj = mergeIntervalList(arr, fields);
+    // console.log('mergeObj', mergeObj, arr);
+    _list.push(mergeObj);
+  }
+  return startList.concat(_list).concat(endList);
+};
+/**
+ * 获取数组中连续小于阈值的项,包含end
+ * @param list
+ * @param threshold
+ * @returns
+ */
+var getBoundaryContinuation = exports.getBoundaryContinuation = function getBoundaryContinuation(list, threshold) {
+  var flag = false,
+    cur = {
+      start: 0,
+      end: 0,
+      item: []
+    };
+  var res = [];
+  for (var i = 0; i < list.length; i++) {
+    if (list[i].value <= threshold) {
+      if (!flag) {
+        cur = {
+          start: i,
+          end: i,
+          item: []
+        };
+        flag = true;
+      }
+      cur.end = i;
+      cur.item.push(list[i]);
+      if (i === list.length - 1 && cur.item.length > 1) {
+        res.push(cur);
+      }
+    } else {
+      if (flag && cur.item.length > 1) {
+        res.push(cur);
+      }
+      flag = false;
+    }
+  }
+  console.log("getBoundaryContinuation", list, threshold, res);
+  return res;
+};
+var getBoundaryMergeStartAndEnd = exports.getBoundaryMergeStartAndEnd = function getBoundaryMergeStartAndEnd(leftBoundary, rightBoundary, leastCount, lastIndex) {
+  var leftEnd = (leftBoundary === null || leftBoundary === void 0 ? void 0 : leftBoundary.end) || -1;
+  var rightStart = (rightBoundary === null || rightBoundary === void 0 ? void 0 : rightBoundary.start) || lastIndex + 1;
+  var unMergeLen = rightStart - leftEnd - 1;
+  var cantMergeNum = leastCount - unMergeLen;
+  if (cantMergeNum <= 0) {
+    return {
+      leftEnd: leftEnd,
+      rightStart: rightStart
+    };
+  }
+  var isMergeLeft = true;
+  if (leftBoundary) {
+    cantMergeNum -= 1;
+  }
+  if (rightBoundary) {
+    cantMergeNum -= 1;
+  }
+  var hasRightLeft = function hasRightLeft() {
+    return rightStart && rightStart < lastIndex;
+  };
+  while (cantMergeNum > 0 && (leftEnd > 0 || hasRightLeft())) {
+    if (leftEnd <= 0) {
+      isMergeLeft = false;
+    } else if (!hasRightLeft()) {
+      isMergeLeft = true;
+    }
+    if (leftEnd > 0 && isMergeLeft) {
+      leftEnd -= 1;
+      cantMergeNum -= 1;
+      isMergeLeft = false;
+    }
+    if (hasRightLeft() && !isMergeLeft) {
+      rightStart += 1;
+      cantMergeNum -= 1;
+      isMergeLeft = true;
+    }
+  }
+  return {
+    leftEnd: leftEnd,
+    rightStart: rightStart
+  };
+};
+var mergeBoundaryIntervals = exports.mergeBoundaryIntervals = function mergeBoundaryIntervals(list, fields) {
+  var _boundaryContinuation, _boundaryContinuation2;
+  var param = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
+    threshold: 0,
+    leastCount: 10
+  };
+  var threshold = param.threshold,
+    leastCount = param.leastCount;
+  var boundaryContinuation = getBoundaryContinuation(list, threshold);
+  console.log("boundaryContinuation", boundaryContinuation);
+  var leftBoundary = ((_boundaryContinuation = boundaryContinuation[0]) === null || _boundaryContinuation === void 0 ? void 0 : _boundaryContinuation.start) === 0 ? boundaryContinuation[0] : null;
+  var len = boundaryContinuation.length;
+  var rightBoundary = ((_boundaryContinuation2 = boundaryContinuation[len - 1]) === null || _boundaryContinuation2 === void 0 ? void 0 : _boundaryContinuation2.end) === list.length - 1 ? boundaryContinuation[len - 1] : null;
+  if (leftBoundary && leftBoundary === rightBoundary) {
+    var middle = Math.ceil(list.length / 2);
+    leftBoundary = {
+      start: 0,
+      end: middle
+    };
+    rightBoundary = {
+      start: middle + 1,
+      end: list.length - 1
+    };
+  }
+  var _getBoundaryMergeStar = getBoundaryMergeStartAndEnd(leftBoundary, rightBoundary, leastCount, list.length - 1),
+    leftEnd = _getBoundaryMergeStar.leftEnd,
+    rightStart = _getBoundaryMergeStar.rightStart;
+  var unMergedList = list.slice(leftEnd + 1, rightStart);
+  var leftMergedList = leftBoundary ? [mergeIntervalList(list.slice(0, leftEnd + 1), fields)] : [];
+  var rightMergedList = rightBoundary ? [mergeIntervalList(list.slice(rightStart, rightBoundary.end + 1), fields)] : [];
+  var rr = leftMergedList.concat(unMergedList).concat(rightMergedList);
+  console.log("mergeBoundaryIntervals", rr, leftMergedList, unMergedList, rightMergedList);
+  return leftMergedList.concat(unMergedList).concat(rightMergedList);
+};
+var smartMergeIntervals = exports.smartMergeIntervals = function smartMergeIntervals(list, fields) {
+  var _boundaryContinuation3, _boundaryContinuation4;
+  var param = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
+    threshold: 0,
+    ratio: 0.5,
+    leastCount: 10
+  };
+  var threshold = param.threshold,
+    ratio = param.ratio;
+  console.log("补0", list);
+  var preMergeData = mergeIntervalsByNum(list, fields, 2, 1, list.length - 1);
+  var boundaryContinuation = getBoundaryContinuation(preMergeData, threshold);
+  console.log("preMergeData", preMergeData);
+  console.log("boundaryContinuation", boundaryContinuation);
+  var leftBoundary = ((_boundaryContinuation3 = boundaryContinuation[0]) === null || _boundaryContinuation3 === void 0 ? void 0 : _boundaryContinuation3.start) === 0 ? boundaryContinuation[0] : null;
+  var len = boundaryContinuation.length;
+  var rightBoundary = boundaryContinuation[len - 1] !== leftBoundary && ((_boundaryContinuation4 = boundaryContinuation[len - 1]) === null || _boundaryContinuation4 === void 0 ? void 0 : _boundaryContinuation4.end) === preMergeData.length - 1 ? boundaryContinuation[len - 1] : null;
+  var leftBoundaryLen = leftBoundary ? leftBoundary.item.length : 0;
+  var rightBoundaryLen = rightBoundary ? rightBoundary.item.length : 0;
+  var _ratio = (leftBoundaryLen + rightBoundaryLen) / preMergeData.length;
+  console.log("ratio", ratio, leftBoundaryLen, rightBoundaryLen);
+  if (_ratio >= ratio) {
+    console.log("auto merge boundary", ratio, _ratio);
+    return mergeBoundaryIntervals(list, fields, param);
+  }
+  return preMergeData;
+};
+var getRangeParams = exports.getRangeParams = function getRangeParams(value) {
+  var dimension = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "";
+  if (!value) return value;
+  var intervals = getIntervals(value);
+  if (intervals) {
+    var res = [];
+    if (isNumeric(intervals[2])) {
+      res.push({
+        type: intervals[1] === "(" ? "gt" : "ge",
+        dimension: dimension,
+        value: intervals[2]
+      });
+    }
+    if (isNumeric(intervals[3])) {
+      res.push({
+        type: intervals[4] === ")" ? "lt" : "le",
+        dimension: dimension,
+        value: intervals[3]
+      });
+    }
+    return res;
+  }
+  var step1 = value.split("<=");
+  if (step1.length === 2) {
+    return [{
+      type: "le",
+      dimension: dimension,
+      value: Number(step1[1])
+    }];
+  }
+  var step2 = value.split("<");
+  if (step2.length === 2) {
+    return [{
+      type: "lt",
+      dimension: dimension,
+      value: Number(step2[1])
+    }];
+  }
+  var step3 = value.split(">=");
+  if (step3.length === 2) {
+    return [{
+      type: "ge",
+      dimension: dimension,
+      value: Number(step3[1])
+    }];
+  }
+  var step4 = value.split(">");
+  if (step4.length === 2) {
+    return [{
+      type: "gt",
+      dimension: dimension,
+      value: Number(step4[1])
+    }];
+  }
+  var ranges = /(-?\d+)-(-?\d+)/.exec(value);
+  if (ranges) {
+    return [{
+      type: "ge",
+      dimension: dimension,
+      value: Number(ranges[1])
+    }, {
+      type: "lt",
+      dimension: dimension,
+      value: Number(ranges[2])
+    }];
+  }
+  return value;
+};
+/**
+ * map结构转换为数组
+ * @param map
+ * @param type
+ * @returns
+ */
+var mapToArr = exports.mapToArr = function mapToArr(map, type) {
+  var iterator = map.entries();
+  var result = [];
+  var _iterator = _createForOfIteratorHelper(iterator),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _step$value = _slicedToArray(_step.value, 2),
+        key = _step$value[0],
+        val = _step$value[1];
+      if (type === "key") result.push(key);
+      if (type === "value") result.push(val);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return result;
+};
+
+/**
+ ** 加法函数，用来得到精确的加法结果
+ ** 说明：javascript的加法结果会有误差，在两个浮点数相加的时候会比较明显。这个函数返回较为精确的加法结果。
+ ** 调用：accAdd(arg1,arg2)
+ ** 返回值：arg1加上arg2的精确结果
+ **/
+var accMod = exports.accMod = function accMod(arg1, arg2) {
+  var r1, m;
+  try {
+    r1 = arg1.toString().split(".")[1].length;
+  } catch (e) {
+    r1 = 0;
+  }
+  if (!r1) {
+    return Number(arg1) / Number(arg2);
+  }
+  m = Math.pow(10, r1);
+  return Number(arg1) * m / (Number(arg2) * m);
+};
+
+/**
+ ** 加法函数，用来得到精确的加法结果
+ ** 说明：javascript的加法结果会有误差，在两个浮点数相加的时候会比较明显。这个函数返回较为精确的加法结果。
+ ** 调用：accAdd(arg1,arg2)
+ ** 返回值：arg1加上arg2的精确结果
+ **/
+var accAdd = exports.accAdd = function accAdd(arg1, arg2) {
+  var r1, r2, m, addParam1, addParam2;
+  try {
+    r1 = arg1.toString().split(".")[1].length;
+  } catch (e) {
+    r1 = 0;
+  }
+  try {
+    r2 = arg2.toString().split(".")[1].length;
+  } catch (e) {
+    r2 = 0;
+  }
+  if (!r1 && !r2) {
+    return Number(arg1) + Number(arg2);
+  }
+  var c = Math.abs(r1 - r2);
+  m = Math.pow(10, Math.max(r1, r2));
+  if (c > 0) {
+    var cm = Math.pow(10, c);
+    if (r1 > r2) {
+      addParam1 = Number(arg1.toString().replace(".", ""));
+      addParam2 = Number(arg2.toString().replace(".", "")) * cm;
+    } else {
+      addParam1 = Number(arg1.toString().replace(".", "")) * cm;
+      addParam2 = Number(arg2.toString().replace(".", ""));
+    }
+  } else {
+    addParam1 = Number(arg1.toString().replace(".", ""));
+    addParam2 = Number(arg2.toString().replace(".", ""));
+  }
+  return (addParam1 + addParam2) / m;
+};