@zgfe/business-lib 1.1.40 → 1.1.41-attribution.10

package/config.js

@@ -0,0 +1,41 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * 对关键配置信息进行本地化存储，避免多人项目配置代码冲突
+ * @param defaultConfig
+ * @returns
+ */
+function getConfig(defaultConfig, basePath) {
+  const configPath = path.resolve(basePath, '.config.json');
+  let resConfig = defaultConfig;
+  try {
+    if (fs.existsSync(configPath)) {
+      const config = fs.readFileSync(configPath, 'utf-8');
+      if (!config || config === '{}') {
+        throw new Error('配置文件为空');
+      }
+      const configObj = JSON.parse(config);
+      // 如果读取的配置文件，数据结构与默认配置不一致，则更新配置文件，更新规则：以默认配置为准，保留用户自定义配置
+      const isSame = Object.keys(defaultConfig).every((key) => {
+        return configObj.hasOwnProperty(key);
+      });
+      if (!isSame) {
+        resConfig = Object.assign({}, defaultConfig, configObj);
+        throw new Error('配置文件数据结构不一致');
+      }
+      resConfig = configObj;
+    } else {
+      throw new Error('配置文件不存在');
+    }
+  } catch (e) {
+    console.log(e.message);
+    fs.writeFileSync(configPath, JSON.stringify(resConfig, null, 2));
+  }
+  console.log('配置详情', resConfig);
+  return resConfig;
+}
+
+module.exports = {
+  getConfig,
+};

package/es/addToPanel/demo/edit.js

@@ -5,7 +5,7 @@ function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len
 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 React, { useState } from 'react';
-import { BizAddToPanel } from '@zgfe/business-lib';
+import { BizAddToPanel, DemoWrapper } from '@zgfe/business-lib';
 import { Button } from 'antd';
 var chartTypes = [{
   label: '趋势图',
@@ -53,7 +53,9 @@ export default (function () {
     _useState2 = _slicedToArray(_useState, 2),
     showDialog = _useState2[0],
     setShowDialog = _useState2[1];
-  return /*#__PURE__*/React.createElement("div", null, /*#__PURE__*/React.createElement(Button, {
+  return /*#__PURE__*/React.createElement(DemoWrapper, {
+    needMeta: true
+  }, /*#__PURE__*/React.createElement("div", null, /*#__PURE__*/React.createElement(Button, {
     onClick: function onClick() {
       setShowDialog(true);
     }
@@ -69,5 +71,5 @@ export default (function () {
     onOk: function onOk() {
       setShowDialog(false);
     }
-  }));
+  })));
 });

package/es/addToPanel/index.js

@@ -216,10 +216,7 @@ var BizAddToPanel = function BizAddToPanel(props) {
     rules: [{
       validator: function validator(_, value) {
         if (props.type === 'edit') {
-          notification.error({
-            message: '指标名称不能为空'
-          });
-          return Promise.reject();
+          return Promise.resolve();
         }
         if (!value || !/\S+/.test(value)) return Promise.reject('请输入指标名称!');
         if (!/^[\S\s]{1,20}$/.test(value)) return Promise.reject('指标名称最多为20个字符!');

package/es/addToPanel/types.d.ts

@@ -21,8 +21,8 @@ declare namespace AddToPanel {
     }
     interface PanelValue {
         id: number;
-        name: string;
-        open_type: number;
+        name?: string;
+        open_type?: number;
     }
     export interface Value {
         panel: PanelValue;

package/es/addToScene/index.js

@@ -56,10 +56,10 @@ var BizAddToScene = function BizAddToScene(props) {
       appId: currentApp === null || currentApp === void 0 ? void 0 : currentApp.appId,
       platform: 0,
       groupId: form.group.groupId,
-      json: JSON.stringify({
+      json: {
         chosen_data: [],
         data: params
-      }),
+      },
       name: form.name
     };
     if (form.group.groupId === 0) {
@@ -70,21 +70,11 @@ var BizAddToScene = function BizAddToScene(props) {
       data: data
     }).then(function (res) {
       setLoading(false);
-      var result = res;
-      if (result.code === 10001) {
+      if (res.data) {
         notification.success({
           message: '添加成功'
         });
         if (props.onOk) props.onOk(res);
-      } else if (result.code === -10010) {
-        notification.error({
-          message: '添加失败',
-          description: data.groupId === 0 ? '场景分类已存在' : '场景名称已存在'
-        });
-      } else {
-        notification.error({
-          message: '添加失败'
-        });
       }
     }).catch(function () {
       setLoading(false);
@@ -104,7 +94,7 @@ var BizAddToScene = function BizAddToScene(props) {
         });
         return;
       }
-      setGroupList(res.groups);
+      setGroupList(res.data);
     });
   }
   useEffect(function () {

package/es/addToScene/types.d.ts

@@ -23,7 +23,7 @@ declare namespace AddToScene {
         groupId: number;
         groupName?: string;
         name: string;
-        json: string;
+        json: {};
     }
 }
 export default AddToScene;

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,25 @@
+import React, { useRef } from 'react';
+import { BizAttrConditionGroup, DemoWrapper } from '@zgfe/business-lib';
+import { Button } from 'antd';
+export default (function () {
+  var groupRef = useRef(null);
+  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' : '')
+  }, "\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,61 @@
+@import '../../assets/styles/inner.less';
+.biz-attr-condition {
+  &-btn-del {
+    color: #9aa1a9;
+    &:hover {
+      color: @error-color;
+      cursor: pointer;
+    }
+  }
+  .biz-attr-select-handle {
+    width: 184px;
+    padding: 0;
+    border: none;
+  }
+  .ant-space-item:nth-of-type(3) {
+    width: 184px;
+  }
+  &-group {
+    display: flex;
+    flex-direction: row;
+    &-container {
+      flex: 1;
+    }
+    &-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;
+      }
+    }
+  }
+}

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;

package/es/attrConditions/components/stringList.js

@@ -141,6 +141,7 @@ var StringList = function StringList(props) {
       size: "middle",
       className: "".concat(classPrefix, "-multi-select"),
       options: [],
+      placeholder: "\u8BF7\u9009\u62E9\u5C5E\u6027\u503C",
       disable: true
     });
   }
@@ -156,7 +157,8 @@ var StringList = function StringList(props) {
     keyField: "value",
     options: options,
     onChange: onChange,
-    onSearch: setSearchValue
+    onSearch: setSearchValue,
+    placeholder: "\u8BF7\u9009\u62E9\u5C5E\u6027\u503C"
   });
 };
 export default StringList;