@zgfe/business-lib 1.0.0-beta.5 → 1.0.3-beta.0

package/es/attrConditions/components/valuesList.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { AttributeSelect } from '../../attributeSelector/types';
+declare const ValuesList: React.FC<{
+    attr?: AttributeSelect.Value;
+    operate?: string;
+    defaultValue?: string[];
+    includeToday?: boolean;
+    onChange?: (value: string[]) => void;
+}>;
+export default ValuesList;

package/es/attrConditions/components/valuesList.js

@@ -0,0 +1,188 @@
+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 = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+import { DatePicker, Input } from 'antd';
+import locale from 'antd/es/date-picker/locale/zh_CN';
+import moment from 'moment';
+import React, { useEffect, useState } from 'react';
+import { classPrefix } from '..';
+import { PropCategory, PropType } from '../../attributeSelector/types';
+import IconFont from '../../components/iconFont';
+import BizSelect from '../../select';
+import { OperateTypes } from '../types';
+import { propSubtype } from '../utils/operates';
+import StringList from './stringList';
+var RangePicker = DatePicker.RangePicker;
+
+var ValuesList = function ValuesList(props) {
+  var attr = props.attr,
+      defaultValue = props.defaultValue,
+      operate = props.operate,
+      includeToday = props.includeToday;
+  var initValue = [moment().subtract(1, 'weeks').format('YYYY-MM-DD'), moment().subtract(includeToday ? 0 : 1, 'days').format('YYYY-MM-DD')];
+
+  var _useState = useState(),
+      _useState2 = _slicedToArray(_useState, 2),
+      current = _useState2[0],
+      setCurrent = _useState2[1];
+
+  var _useState3 = useState('1'),
+      _useState4 = _slicedToArray(_useState3, 2),
+      unit = _useState4[0],
+      setUnit = _useState4[1];
+
+  var _useState5 = useState(true),
+      _useState6 = _slicedToArray(_useState5, 2),
+      ready = _useState6[0],
+      setReady = _useState6[1];
+
+  useEffect(function () {
+    if (defaultValue) {
+      if ((attr === null || attr === void 0 ? void 0 : attr.propCategory) === 'userProp' && (attr === null || attr === void 0 ? void 0 : attr.subtype) === 2) {
+        var num = String(parseFloat(defaultValue[0]) / getUnitCount(defaultValue[1]));
+        setCurrent([num, defaultValue[1]]);
+      } else {
+        setCurrent(defaultValue);
+      }
+    }
+
+    setReady(false);
+  }, []);
+  useEffect(function () {
+    if (operate === OperateTypes.Absolute || operate === OperateTypes.Relative) {
+      var data = operate === OperateTypes.Absolute ? initValue : ['30', '1'];
+      onChange(data);
+    }
+  }, [operate]);
+  useEffect(function () {
+    if (!ready && (attr === null || attr === void 0 ? void 0 : attr.type) !== PropType.DATE) {
+      onChange([]);
+      setCurrent([]);
+    }
+  }, [attr]);
+
+  var onChange = function onChange(data) {
+    setCurrent(data);
+    if (props.onChange) props.onChange(data);
+  };
+
+  var onChangeRange = function onChangeRange() {
+    onChange(arguments.length <= 1 ? undefined : arguments[1]);
+  };
+
+  var onChangeDate = function onChangeDate(e) {
+    var data = [e.target.value, '1'];
+    onChange(data);
+  };
+
+  var onChangeNumber = function onChangeNumber(e) {
+    var data = [e.target.value];
+
+    if ((attr === null || attr === void 0 ? void 0 : attr.propCategory) === PropCategory.UserProp && (attr === null || attr === void 0 ? void 0 : attr.subtype) === 2) {
+      var num = String(parseFloat(e.target.value) * getUnitCount(unit));
+      data = [num, unit];
+      setCurrent([e.target.value, unit]);
+    } else {
+      setCurrent(data);
+    }
+
+    if (props.onChange) props.onChange(data);
+  };
+
+  var onChangeUnit = function onChangeUnit(data) {
+    setUnit(data.value);
+
+    if (current && current[0]) {
+      var num = String(parseFloat(current[0]) * getUnitCount(data.value));
+      if (props.onChange) props.onChange([num, data.value]);
+    }
+  };
+
+  var getUnitCount = function getUnitCount(value) {
+    return value === '1' ? 3600 : value === '2' ? 60 : 1;
+  };
+
+  var disabledDate = function disabledDate(current) {
+    return current && current > moment().endOf('day');
+  };
+
+  if (!attr || !operate || ready) {
+    return /*#__PURE__*/React.createElement(BizSelect, {
+      disable: true,
+      className: "".concat(classPrefix, "-multi-select"),
+      theme: "secondary",
+      size: "base",
+      options: []
+    });
+  }
+
+  if (attr.type === PropType.STRING) {
+    return /*#__PURE__*/React.createElement(StringList, {
+      attr: attr,
+      operate: operate,
+      value: current,
+      onChange: onChange
+    });
+  } else if (attr.type === PropType.NUMBER) {
+    var numberAfter = /*#__PURE__*/React.createElement(BizSelect, {
+      defaultValue: {
+        value: current && ['1', '2', '3'].includes(current[1]) ? current[1] : unit
+      },
+      keyField: "value",
+      labelField: "label",
+      theme: "secondary",
+      className: "".concat(classPrefix, "-input-select"),
+      onChange: onChangeUnit,
+      options: propSubtype
+    });
+    return /*#__PURE__*/React.createElement(Input, {
+      className: "".concat(classPrefix, "-input"),
+      value: current && current.length ? current[0] : '',
+      placeholder: "\u8BF7\u8F93\u5165",
+      type: "number",
+      onChange: onChangeNumber,
+      addonAfter: attr.propCategory === 'userProp' && attr.subtype === 1 ? '%' : attr.propCategory === 'userProp' && attr.subtype === 2 ? numberAfter : null
+    });
+  } else {
+    if (operate === OperateTypes.Absolute) {
+      return /*#__PURE__*/React.createElement(RangePicker, {
+        value: [moment(current[0], 'YYYY-MM-DD'), moment(current[1], 'YYYY-MM-DD')],
+        allowClear: false,
+        className: "".concat(classPrefix, "-date"),
+        inputReadOnly: true,
+        locale: locale,
+        disabledDate: disabledDate,
+        placement: 'bottomRight',
+        separator: '至',
+        suffixIcon: /*#__PURE__*/React.createElement(IconFont, {
+          type: 'icon-shijian1'
+        }),
+        format: 'YYYY-MM-DD',
+        onChange: onChangeRange
+      });
+    } else {
+      return /*#__PURE__*/React.createElement(Input, {
+        className: "".concat(classPrefix, "-input"),
+        value: current && current[0] ? current[0] : 30,
+        placeholder: "\u8BF7\u8F93\u5165",
+        type: "number",
+        addonAfter: "\u5929",
+        onChange: onChangeDate
+      });
+    }
+  }
+};
+
+ValuesList.defaultProps = {
+  includeToday: false
+};
+export default ValuesList;

package/es/attrConditions/demo/group.js

@@ -0,0 +1,82 @@
+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 = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+import React, { useRef, useState } from 'react';
+import { BizGlobalDataContext, BizConditionGroup, convertAttributeData } from '@zgfe/business-lib';
+import eventData from '../../mock/event';
+import envData from '../../mock/env';
+import userData from '../../mock/user';
+import { Button } from 'antd';
+var conditions = [{
+  propCategory: 'userProp',
+  type: 2,
+  operation: 'gt',
+  values: ['25200', '1'],
+  attrName: 'duration',
+  category: 'fixed',
+  subtype: 2
+}, {
+  propCategory: 'eventProp',
+  type: 1,
+  operation: 'equal',
+  values: ['Safari', 'Apple WebKit'],
+  attrId: 30183426
+}];
+export default (function () {
+  var _useState = useState({
+    relation: 'and',
+    conditions: conditions
+  }),
+      _useState2 = _slicedToArray(_useState, 2),
+      data = _useState2[0],
+      setData = _useState2[1];
+
+  var store = convertAttributeData({
+    eventList: eventData,
+    userPropList: userData,
+    envPropList: envData
+  });
+
+  var _useState3 = useState(conditions.length),
+      _useState4 = _slicedToArray(_useState3, 2),
+      count = _useState4[0],
+      setCount = _useState4[1];
+
+  var conditionRef = useRef(null);
+
+  var onChange = function onChange(value) {
+    setData(value);
+  };
+
+  var onClick = function onClick() {
+    conditionRef.current.add();
+  };
+
+  return /*#__PURE__*/React.createElement(BizGlobalDataContext.Provider, {
+    value: {
+      eventGroupList: store.eventGroupList,
+      userPropList: store.userPropList,
+      eventEnvList: store.envPropList,
+      currentApp: {
+        appId: 35510,
+        platform: 0
+      }
+    }
+  }, /*#__PURE__*/React.createElement(BizConditionGroup, {
+    ref: conditionRef,
+    value: data,
+    onChange: onChange,
+    onConditionsCount: setCount
+  }), /*#__PURE__*/React.createElement("br", null), count < 3 && /*#__PURE__*/React.createElement(Button, {
+    onClick: onClick
+  }, "\u6DFB\u52A0"), /*#__PURE__*/React.createElement("br", null), /*#__PURE__*/React.createElement("br", null), /*#__PURE__*/React.createElement("p", null, "\u5F53\u524D\u503C\uFF1A", JSON.stringify(data)));
+});

package/es/{datePicker/demo/form.js → attrConditions/demo/index.js}

@@ -11,43 +11,63 @@ function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Sy
 function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 
 import React, { useState } from 'react';
-import { Button, Form } from 'antd';
-import { BizDatePicker } from '@zgfe/business-lib';
+import { BizGlobalDataContext, BizConditionItem, convertAttributeData } from '@zgfe/business-lib';
+import eventData from '../../mock/event';
+import envData from '../../mock/env';
+import userData from '../../mock/user';
+import { Form } from 'antd';
 export default (function () {
   var _Form$useForm = Form.useForm(),
       _Form$useForm2 = _slicedToArray(_Form$useForm, 1),
       form = _Form$useForm2[0];
 
   var _useState = useState({
-    time: {}
+    condition: {
+      propCategory: 'userProp',
+      type: 2,
+      operation: 'lt',
+      values: ['25200', '1'],
+      subtype: 2,
+      attrName: 'duration',
+      category: 'fixed'
+    }
   }),
       _useState2 = _slicedToArray(_useState, 2),
       formData = _useState2[0],
       setFormData = _useState2[1];
 
-  var onFinish = function onFinish(values) {
-    setFormData(values);
-  };
+  var store = convertAttributeData({
+    eventList: eventData,
+    userPropList: userData,
+    envPropList: envData
+  });
 
-  var onFinishFailed = function onFinishFailed(errorInfo) {
-    console.log('Failed:', errorInfo);
+  var onChange = function onChange() {
+    setFormData(arguments.length <= 1 ? undefined : arguments[1]);
   };
 
-  return /*#__PURE__*/React.createElement("div", null, /*#__PURE__*/React.createElement(Form, {
+  return /*#__PURE__*/React.createElement(BizGlobalDataContext.Provider, {
+    value: {
+      eventGroupList: store.eventGroupList,
+      userPropList: store.userPropList,
+      eventEnvList: store.envPropList,
+      currentApp: {
+        appId: 35510,
+        platform: 0
+      }
+    }
+  }, /*#__PURE__*/React.createElement(Form, {
     form: form,
-    onFinish: onFinish,
-    onFinishFailed: onFinishFailed,
-    initialValues: formData
+    initialValues: formData,
+    onValuesChange: onChange
   }, /*#__PURE__*/React.createElement(Form.Item, {
-    label: "",
-    name: "time"
-  }, /*#__PURE__*/React.createElement(BizDatePicker, null)), /*#__PURE__*/React.createElement(Form.Item, {
-    wrapperCol: {
-      offset: 8,
-      span: 16
-    }
-  }, /*#__PURE__*/React.createElement(Button, {
-    type: "primary",
-    htmlType: "submit"
-  }, "Submit"))), /*#__PURE__*/React.createElement("p", null, JSON.stringify(formData)));
+    name: "condition"
+  }, /*#__PURE__*/React.createElement(BizConditionItem, {
+    eventIdList: [24143016, 24256188, 24095076],
+    enableEventProp: true,
+    disableItemList: [{
+      name: 'is_anonymous',
+      propCategory: 'userProp'
+    }]
+  }))), /*#__PURE__*/React.createElement("br", null), /*#__PURE__*/React.createElement("p", null, "\u5F53\u524Dform\u503C\uFF1A", JSON.stringify(formData)));
 });

package/es/attrConditions/group.d.ts

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

package/es/attrConditions/group.js

@@ -0,0 +1,183 @@
+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 = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+import React, { useEffect, useImperativeHandle, useState } from 'react';
+import BizConditionItem from './index';
+import './styles/group.less';
+import _ from 'lodash';
+import { Skeleton } from 'antd';
+
+var BizConditionGroup = function BizConditionGroup(props, ref) {
+  var eventIdList = props.eventIdList,
+      enableDelete = props.enableDelete,
+      enableEventProp = props.enableEventProp,
+      enableUserProp = props.enableUserProp,
+      enableEnvProp = props.enableEnvProp,
+      disableItemList = props.disableItemList,
+      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),
+      ready = _useState6[0],
+      setReady = _useState6[1];
+
+  var classPrefix = 'biz-condition';
+  useEffect(function () {
+    var data = props.defaultValue || props.value;
+
+    if (data) {
+      if (data.relation) setRelation(data.relation);
+
+      if (data.conditions) {
+        setConditions(function () {
+          return addKeyToGroup(data.conditions);
+        });
+      }
+    }
+
+    setReady(false);
+  }, []);
+  useImperativeHandle(ref, function () {
+    return {
+      add: function add() {
+        onConditionsCount && onConditionsCount(conditions.length + 1);
+        setConditions(function (conditions) {
+          conditions.push({
+            key: Math.random()
+          });
+          return _toConsumableArray(conditions);
+        });
+      }
+    };
+  });
+
+  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 /*#__PURE__*/React.createElement("div", {
+    className: classPrefix
+  }, /*#__PURE__*/React.createElement(Skeleton, {
+    loading: ready,
+    active: true,
+    paragraph: {
+      rows: 2
+    }
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-group-handle")
+  }, conditions.length > 1 && /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-group-operate"),
+    onClick: onClickRelation
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-group-operate-text ").concat(relation === 'and' ? 'active' : '')
+  }, "\u4E14"), /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-group-operate-text ").concat(relation === 'or' ? 'active' : '')
+  }, "\u6216"))), /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-item-container")
+  }, conditions.map(function (item, index) {
+    return /*#__PURE__*/React.createElement(BizConditionItem, {
+      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(BizConditionGroup);

package/es/attrConditions/index.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import './styles/index.less';
+import { AttrConditionTypes } from './types';
+export declare const classPrefix = "biz-condition-item";
+declare const BizConditionItem: React.FC<AttrConditionTypes.ItemProp>;
+export default BizConditionItem;