@zgfe/business-lib 1.1.51 → 1.1.52

package/es/assets/iconfont/iconfont.json

@@ -5,6 +5,76 @@
   "css_prefix_text": "",
   "description": "诸葛业务平台",
   "glyphs": [
+    {
+      "icon_id": "36023911",
+      "name": "归因",
+      "font_class": "guiyin",
+      "unicode": "e764",
+      "unicode_decimal": 59236
+    },
+    {
+      "icon_id": "36017810",
+      "name": "筛选",
+      "font_class": "shaixuan",
+      "unicode": "e76e",
+      "unicode_decimal": 59246
+    },
+    {
+      "icon_id": "36017811",
+      "name": "清除",
+      "font_class": "qingchu",
+      "unicode": "e759",
+      "unicode_decimal": 59225
+    },
+    {
+      "icon_id": "35960341",
+      "name": "数据去重",
+      "font_class": "shujuquzhong",
+      "unicode": "e761",
+      "unicode_decimal": 59233
+    },
+    {
+      "icon_id": "35960342",
+      "name": "替换缺失值",
+      "font_class": "tihuanqueshizhi",
+      "unicode": "e762",
+      "unicode_decimal": 59234
+    },
+    {
+      "icon_id": "35892782",
+      "name": "播放",
+      "font_class": "bofang",
+      "unicode": "e75b",
+      "unicode_decimal": 59227
+    },
+    {
+      "icon_id": "35892783",
+      "name": "方向上",
+      "font_class": "fangxiangshang",
+      "unicode": "e75c",
+      "unicode_decimal": 59228
+    },
+    {
+      "icon_id": "35892784",
+      "name": "暂停",
+      "font_class": "zanting",
+      "unicode": "e75e",
+      "unicode_decimal": 59230
+    },
+    {
+      "icon_id": "35892785",
+      "name": "音量",
+      "font_class": "yinliang",
+      "unicode": "e75f",
+      "unicode_decimal": 59231
+    },
+    {
+      "icon_id": "35892786",
+      "name": "方向下",
+      "font_class": "fangxiangxia",
+      "unicode": "e760",
+      "unicode_decimal": 59232
+    },
     {
       "icon_id": "34970302",
       "name": "用户",
@@ -642,13 +712,6 @@
       "unicode": "e757",
       "unicode_decimal": 59223
     },
-    {
-      "icon_id": "28442442",
-      "name": "清除",
-      "font_class": "qingchu",
-      "unicode": "e759",
-      "unicode_decimal": 59225
-    },
     {
       "icon_id": "28442453",
       "name": "向下",
@@ -656,13 +719,6 @@
       "unicode": "e76d",
       "unicode_decimal": 59245
     },
-    {
-      "icon_id": "28444857",
-      "name": "筛选",
-      "font_class": "shaixuan",
-      "unicode": "e76e",
-      "unicode_decimal": 59246
-    },
     {
       "icon_id": "28447646",
       "name": "添加",

package/es/attrCondition/demo/ajaxConfig.d.ts

@@ -0,0 +1,8 @@
+export declare const requestConfig: {
+    request: {
+        optionsWrapper(url: string, options?: any): {
+            url: string;
+            options: any;
+        };
+    };
+};

package/es/attrCondition/demo/ajaxConfig.js

@@ -0,0 +1,40 @@
+import _ from 'lodash';
+function setOptionWapper(url, options) {
+  var reqOption = _.cloneDeep(options);
+  if (/^\/v1|\.jsp$/.test(url)) {
+    if (reqOption.headers && reqOption.headers['Content-Type'] === 'application/x-www-form-urlencoded') {
+      return reqOption;
+    }
+    reqOption.headers = {
+      'Content-Type': 'application/x-www-form-urlencoded'
+    };
+    var transformRequest = function transformRequest(param) {
+      var arr = [];
+      for (var key in param) {
+        arr.push("".concat(key, "=").concat(encodeURIComponent(param[key])));
+      }
+      return arr.join('&');
+    };
+    reqOption.data = transformRequest(options.data);
+  }
+  return reqOption;
+}
+export var requestConfig = {
+  request: {
+    optionsWrapper: function optionsWrapper(url, options) {
+      var newUrl = url;
+      var reqOption = options;
+      var ajaxUrlReg = '/analysis/api/common/proxy';
+      if (/^\/v1|\.jsp$/.test(url)) {
+        if (ajaxUrlReg && !url.includes(ajaxUrlReg)) {
+          newUrl = ajaxUrlReg + url;
+          reqOption = setOptionWapper(url, options);
+        }
+      }
+      return {
+        url: newUrl,
+        options: reqOption
+      };
+    }
+  }
+};

package/es/attrCondition/demo/group.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => JSX.Element;
+export default _default;

package/es/attrCondition/demo/group.js

@@ -0,0 +1,29 @@
+import React, { useRef, useEffect } from 'react';
+import { BizAttrConditionGroup, DemoWrapper, setGlobalConfig } from '@zgfe/business-lib';
+import { Button } from 'antd';
+import { requestConfig } from './ajaxConfig';
+export default (function () {
+  var groupRef = useRef(null);
+  useEffect(function () {
+    setGlobalConfig(requestConfig);
+  }, []);
+  return /*#__PURE__*/React.createElement(DemoWrapper, {
+    needMeta: true
+  }, /*#__PURE__*/React.createElement("div", {
+    style: {
+      padding: '16px',
+      background: '#fff'
+    }
+  }, /*#__PURE__*/React.createElement(BizAttrConditionGroup, {
+    ref: groupRef,
+    enableDelete: true
+  }), /*#__PURE__*/React.createElement("div", {
+    style: {
+      marginTop: '16px'
+    }
+  }, /*#__PURE__*/React.createElement(Button, {
+    onClick: function onClick() {
+      groupRef.current.add();
+    }
+  }, "\u6DFB\u52A0\u6761\u4EF6"))));
+});

package/es/attrCondition/demo/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => JSX.Element;
+export default _default;

package/es/attrCondition/demo/index.js

@@ -0,0 +1,16 @@
+import React from 'react';
+import { BizAttrCondition, DemoWrapper } from '@zgfe/business-lib';
+export default (function () {
+  return /*#__PURE__*/React.createElement(DemoWrapper, {
+    needMeta: true
+  }, /*#__PURE__*/React.createElement("div", {
+    style: {
+      padding: '16px',
+      background: '#fff'
+    }
+  }, /*#__PURE__*/React.createElement(BizAttrCondition, {
+    onChange: function onChange(condition) {
+      console.log(condition);
+    }
+  })));
+});

package/es/attrCondition/group.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { AttrConditionTypes } from '../attrConditions/types';
+declare const _default: React.ForwardRefExoticComponent<AttrConditionTypes.GroupProp & React.RefAttributes<any>>;
+export default _default;

package/es/attrCondition/group.js

@@ -0,0 +1,59 @@
+import React from 'react';
+import useConditionGroup from './useConditionGroup';
+import { Skeleton, Space } from 'antd';
+import BizAttrCondition from '.';
+var BizAttrConditionGroup = function BizAttrConditionGroup(props, ref) {
+  var eventIdList = props.eventIdList,
+    enableDelete = props.enableDelete,
+    enableEventProp = props.enableEventProp,
+    enableUserProp = props.enableUserProp,
+    enableEnvProp = props.enableEnvProp,
+    disableItemList = props.disableItemList;
+  var _useConditionGroup = useConditionGroup(props, ref),
+    loading = _useConditionGroup.loading,
+    conditions = _useConditionGroup.conditions,
+    _onChange = _useConditionGroup.onChange,
+    onClickRelation = _useConditionGroup.onClickRelation,
+    _onDelete = _useConditionGroup.onDelete,
+    relation = _useConditionGroup.relation;
+  var classPrefix = 'biz-attr-condition-group';
+  return /*#__PURE__*/React.createElement("div", {
+    className: classPrefix
+  }, /*#__PURE__*/React.createElement(Skeleton, {
+    loading: loading,
+    active: true,
+    paragraph: {
+      rows: 2
+    }
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-handle")
+  }, conditions.length > 1 && /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-operate"),
+    onClick: onClickRelation
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-operate-text ").concat(relation === 'and' || props.onlyAnd ? 'active' : '', " ").concat(props.onlyAnd ? 'only-and' : '')
+  }, "\u4E14"), !props.onlyAnd && /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-operate-text ").concat(relation === 'or' ? 'active' : '')
+  }, "\u6216"))), /*#__PURE__*/React.createElement(Space, {
+    className: "".concat(classPrefix, "-container"),
+    direction: "vertical"
+  }, conditions.map(function (item, index) {
+    return /*#__PURE__*/React.createElement(BizAttrCondition, {
+      key: item.key,
+      value: item.data,
+      eventIdList: eventIdList,
+      enableDelete: enableDelete,
+      enableEventProp: enableEventProp,
+      enableUserProp: enableUserProp,
+      enableEnvProp: enableEnvProp,
+      disableItemList: disableItemList,
+      onChange: function onChange(data) {
+        return _onChange(data, index);
+      },
+      onDelete: function onDelete() {
+        return _onDelete(index);
+      }
+    });
+  }))));
+};
+export default /*#__PURE__*/React.forwardRef(BizAttrConditionGroup);

package/es/attrCondition/index.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { AttrConditionTypes } from '../attrConditions/types';
+import './styles/index.less';
+declare const BizAttrCondition: React.FC<AttrConditionTypes.ItemProp>;
+export default BizAttrCondition;

package/es/attrCondition/index.js

@@ -0,0 +1,67 @@
+import { Skeleton, Space } from 'antd';
+import React from 'react';
+import BizAttributeSelector from '../attributeSelector';
+import BizOperateList from '../attrConditions/components/operateList';
+import ValuesList from '../attrConditions/components/valuesList';
+import useAttrCondition from './useAttrCondition';
+import './styles/index.less';
+import IconFont from '../icon/iconFont';
+var classPrefix = 'biz-attr-condition';
+var BizAttrCondition = function BizAttrCondition(props) {
+  var eventIdList = props.eventIdList,
+    enableDelete = props.enableDelete,
+    enableEventProp = props.enableEventProp,
+    enableUserProp = props.enableUserProp,
+    enableEnvProp = props.enableEnvProp,
+    disableItemList = props.disableItemList,
+    theme = props.theme;
+  var _useAttrCondition = useAttrCondition(props),
+    loading = _useAttrCondition.loading,
+    attr = _useAttrCondition.attr,
+    operate = _useAttrCondition.operate,
+    values = _useAttrCondition.values,
+    onChangeAttr = _useAttrCondition.onChangeAttr,
+    onChangeOperate = _useAttrCondition.onChangeOperate,
+    onChangeValues = _useAttrCondition.onChangeValues,
+    onDelete = _useAttrCondition.onDelete;
+  return /*#__PURE__*/React.createElement(Space, {
+    className: classPrefix
+  }, !loading ? /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(BizAttributeSelector, {
+    value: attr,
+    eventIdList: eventIdList,
+    enableEventProp: enableEventProp,
+    enableUserProp: enableUserProp,
+    enableEnvProp: enableEnvProp,
+    disableItemList: disableItemList,
+    onChange: onChangeAttr,
+    theme: theme,
+    destroyPopupOnHide: props.destroyPopupOnHide,
+    placeholder: "\u8BF7\u9009\u62E9\u5C5E\u6027"
+  }), /*#__PURE__*/React.createElement(BizOperateList, {
+    theme: theme,
+    attr: attr,
+    defaultValue: operate,
+    onChange: onChangeOperate
+  }), /*#__PURE__*/React.createElement(ValuesList, {
+    attr: attr,
+    operate: operate,
+    defaultValue: values,
+    onChange: onChangeValues,
+    theme: theme
+  }), enableDelete && /*#__PURE__*/React.createElement(IconFont, {
+    type: "qingchu",
+    className: "".concat(classPrefix, "-btn-del"),
+    onClick: onDelete
+  })) : /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(Skeleton.Input, {
+    active: true
+  }), /*#__PURE__*/React.createElement(Skeleton.Input, {
+    active: true
+  }), /*#__PURE__*/React.createElement(Skeleton.Input, {
+    active: true
+  })));
+};
+BizAttrCondition.defaultProps = {
+  border: false,
+  theme: ''
+};
+export default BizAttrCondition;

package/es/attrCondition/styles/index.less

@@ -0,0 +1,74 @@
+@import '../../assets/styles/inner.less';
+.biz-attr-condition {
+  gap: 16px !important;
+  width: 100%;
+  &-btn-del {
+    color: #9aa1a9;
+    font-size: 20px !important;
+    &:hover {
+      color: @error-color;
+      cursor: pointer;
+    }
+  }
+  .biz-attr-select-handle {
+    width: 184px;
+    padding: 0;
+    border: none;
+  }
+  .ant-space-item:nth-of-type(3) {
+    min-width: 184px;
+    max-width: calc(100% - 320px);
+  }
+  &-group {
+    display: flex;
+    flex-direction: row;
+    .ant-space-item:nth-of-type(3) {
+      min-width: 184px;
+      max-width: calc(100% - 380px);
+    }
+    &-container {
+      flex: 1;
+      gap: 12px !important;
+      width: 100%;
+    }
+    &-handle {
+      position: relative;
+      width: 1px;
+      margin-right: 16px;
+      margin-left: 8px;
+      background: @border-color-base;
+    }
+    &-operate {
+      position: absolute;
+      top: 50%;
+      left: 50%;
+      width: 16px;
+      transform: translate(-50%, -50%);
+    }
+    &-operate-text {
+      width: 16px;
+      height: 16px;
+      font-size: 12px;
+      line-height: 16px;
+      text-align: center;
+
+      .__default-hover();
+
+      &:first-child {
+        border-radius: @border-radius-sx @border-radius-sx 0px 0px;
+      }
+
+      &:last-child {
+        border-radius: 0px 0px @border-radius-sx @border-radius-sx;
+      }
+
+      &.active {
+        color: #fff;
+        background: @primary-color;
+      }
+    }
+    &-operate-text.only-and {
+      border-radius: 2px;
+    }
+  }
+}

package/es/attrCondition/useAttrCondition.d.ts

@@ -0,0 +1,13 @@
+import { AttrConditionTypes } from '../attrConditions/types';
+import { AttributeSelect } from '../attributeSelector/types';
+declare const useAttrCondition: (props: AttrConditionTypes.ItemProp) => {
+    attr: AttributeSelect.Value | undefined;
+    operate: import("../attrConditions/types").OperateTypes | undefined;
+    values: string[] | undefined;
+    loading: boolean;
+    onDelete: () => void;
+    onChangeAttr: (attrData: AttributeSelect.Value) => void;
+    onChangeOperate: (data: any) => void;
+    onChangeValues: (data: any) => void;
+};
+export default useAttrCondition;

package/es/attrCondition/useAttrCondition.js

@@ -0,0 +1,91 @@
+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 _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 _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import { useEffect, useState } from 'react';
+import { PropCategory } from '../attributeSelector/types';
+import { getCondition } from '../attrConditions';
+var useAttrCondition = function useAttrCondition(props) {
+  var _props$defaultValue, _props$value, _props$defaultValue2, _props$value2;
+  var _useState = useState(),
+    _useState2 = _slicedToArray(_useState, 2),
+    attr = _useState2[0],
+    setAttr = _useState2[1];
+  var _useState3 = useState(((_props$defaultValue = props.defaultValue) === null || _props$defaultValue === void 0 ? void 0 : _props$defaultValue.operator) || ((_props$value = props.value) === null || _props$value === void 0 ? void 0 : _props$value.operator)),
+    _useState4 = _slicedToArray(_useState3, 2),
+    operate = _useState4[0],
+    setOperate = _useState4[1];
+  var _useState5 = useState(((_props$defaultValue2 = props.defaultValue) === null || _props$defaultValue2 === void 0 ? void 0 : _props$defaultValue2.values) || ((_props$value2 = props.value) === null || _props$value2 === void 0 ? void 0 : _props$value2.values)),
+    _useState6 = _slicedToArray(_useState5, 2),
+    values = _useState6[0],
+    setValues = _useState6[1];
+  var _useState7 = useState(true),
+    _useState8 = _slicedToArray(_useState7, 2),
+    loading = _useState8[0],
+    setLoading = _useState8[1];
+  useEffect(function () {
+    var data = props.defaultValue || props.value;
+    if (data) {
+      var attrData;
+      if (data.propCategory === PropCategory.EventProp) {
+        if (data.attrId) {
+          attrData = {
+            id: data.attrId,
+            propCategory: data.propCategory,
+            type: data.type,
+            key: data.attrId,
+            label: data.label,
+            dimensionSub: data.dimensionSub || 'event_attr'
+          };
+        }
+      } else if (data.propCategory === PropCategory.UserProp || data.propCategory === PropCategory.EnvProp) {
+        if (data.attrName) {
+          var aId = data.attrId || 0;
+          attrData = {
+            id: aId,
+            name: data.attrName,
+            propCategory: data.propCategory,
+            type: data.type,
+            category: data.category,
+            key: "".concat(data.propCategory, "-").concat(data.dimensionSub || data.attrName, "-").concat(aId),
+            subtype: data.subtype,
+            dimensionSub: data.dimensionSub || data.attrName
+          };
+        }
+      }
+      setAttr(attrData);
+    }
+    setLoading(false);
+  }, []);
+  var onDelete = function onDelete() {
+    if (props.onDelete) props.onDelete();
+  };
+  useEffect(function () {
+    if (props.onChange) {
+      if (!attr) return;
+      props.onChange(getCondition(attr, operate, values));
+    }
+  }, [attr, operate, values]);
+  var onChangeAttr = function onChangeAttr(attrData) {
+    setAttr(attrData);
+  };
+  var onChangeOperate = function onChangeOperate(data) {
+    setOperate(data);
+  };
+  var onChangeValues = function onChangeValues(data) {
+    setValues(data);
+  };
+  return {
+    attr: attr,
+    operate: operate,
+    values: values,
+    loading: loading,
+    onDelete: onDelete,
+    onChangeAttr: onChangeAttr,
+    onChangeOperate: onChangeOperate,
+    onChangeValues: onChangeValues
+  };
+};
+export default useAttrCondition;

package/es/attrCondition/useConditionGroup.d.ts

@@ -0,0 +1,10 @@
+import { AttrConditionTypes } from '../attrConditions/types';
+declare const useConditionGroup: (props: AttrConditionTypes.GroupProp, ref: React.ForwardedRef<any>) => {
+    relation: "and" | "or";
+    conditions: AttrConditionTypes.GroupAddKey[];
+    loading: boolean;
+    onClickRelation: (e: any) => void;
+    onChange: (data: AttrConditionTypes.ItemValue, index: number) => void;
+    onDelete: (index: number) => void;
+};
+export default useConditionGroup;

package/es/attrCondition/useConditionGroup.js

@@ -0,0 +1,127 @@
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+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 _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 _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import { useState, useEffect, useImperativeHandle } from 'react';
+import _ from 'lodash';
+var useConditionGroup = function useConditionGroup(props, ref) {
+  var onConditionsCount = props.onConditionsCount;
+  var _useState = useState('and'),
+    _useState2 = _slicedToArray(_useState, 2),
+    relation = _useState2[0],
+    setRelation = _useState2[1];
+  var _useState3 = useState([]),
+    _useState4 = _slicedToArray(_useState3, 2),
+    conditions = _useState4[0],
+    setConditions = _useState4[1];
+  var _useState5 = useState(true),
+    _useState6 = _slicedToArray(_useState5, 2),
+    loading = _useState6[0],
+    setLoading = _useState6[1];
+  useEffect(function () {
+    var data = props.defaultValue || props.value;
+    if (data) {
+      if (data.relation) setRelation(props.onlyAnd ? 'and' : data.relation);
+      if (data.conditions) {
+        setConditions(function () {
+          return addKeyToGroup(data.conditions);
+        });
+      }
+    }
+    setLoading(false);
+  }, []);
+  useImperativeHandle(ref, function () {
+    return {
+      add: function add() {
+        onConditionsCount && onConditionsCount(conditions.length + 1);
+        setConditions(function (conditions) {
+          conditions.push({
+            key: Math.random()
+          });
+          return _toConsumableArray(conditions);
+        });
+      },
+      setValue: function setValue(data) {
+        if (data) {
+          if (data.relation) setRelation(props.onlyAnd ? 'and' : data.relation);
+          if (data.conditions) {
+            setConditions(function () {
+              return addKeyToGroup(data.conditions);
+            });
+          }
+        } else {
+          setRelation('and');
+          setConditions([]);
+        }
+      }
+    };
+  });
+  var addKeyToGroup = function addKeyToGroup(data) {
+    return data.map(function (item) {
+      return {
+        key: Math.random(),
+        data: item
+      };
+    });
+  };
+  var removeKeyToGroup = function removeKeyToGroup(data) {
+    var group = [];
+    data.forEach(function (item) {
+      if (item.data) group.push(item.data);
+    });
+    return group;
+  };
+  var onClickRelation = function onClickRelation(e) {
+    e.stopPropagation();
+    var data = e.target.innerText === '且' ? 'and' : 'or';
+    setRelation(data);
+    if (props.onChange) {
+      var group = removeKeyToGroup(conditions);
+      props.onChange({
+        relation: data,
+        conditions: group
+      });
+    }
+  };
+  var onChange = function onChange(data, index) {
+    var conditionArr = _.cloneDeep(conditions);
+    conditionArr[index].data = data;
+    setConditions(conditionArr);
+    onConditionsCount && onConditionsCount(conditionArr.length);
+    if (props.onChange) {
+      var group = removeKeyToGroup(conditionArr);
+      props.onChange({
+        relation: relation,
+        conditions: group
+      });
+    }
+  };
+  var onDelete = function onDelete(index) {
+    var conditionArr = _.cloneDeep(conditions);
+    conditionArr.splice(index, 1);
+    setConditions(conditionArr);
+    onConditionsCount && onConditionsCount(conditionArr.length);
+    if (props.onChange) {
+      var group = removeKeyToGroup(conditionArr);
+      props.onChange({
+        relation: relation,
+        conditions: group
+      });
+    }
+  };
+  return {
+    relation: relation,
+    conditions: conditions,
+    loading: loading,
+    onClickRelation: onClickRelation,
+    onChange: onChange,
+    onDelete: onDelete
+  };
+};
+export default useConditionGroup;