@zgfe/business-lib 1.0.1-beta.0 → 1.0.5

package/es/userCondition/conditionTypeList.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import './styles/conditionTypeList.less';
+import { BizUserConditionT } from './types';
+export interface ConditionTypeListPropsI {
+    onAdd: (type: BizUserConditionT.ConditionType) => void;
+    label?: string | React.ReactDOM;
+    show?: boolean;
+}
+declare const ConditionTypeList: React.FC<ConditionTypeListPropsI>;
+export default ConditionTypeList;

package/es/userCondition/conditionTypeList.js

@@ -0,0 +1,43 @@
+import React from 'react';
+import { Space } from 'antd';
+import { PlusOutlined } from '@ant-design/icons';
+import './styles/conditionTypeList.less';
+
+var ConditionTypeList = function ConditionTypeList(props) {
+  var onAdd = props.onAdd,
+      label = props.label,
+      show = props.show;
+  if (!show) return null;
+  return /*#__PURE__*/React.createElement("div", {
+    className: "biz-user-condition-type-list"
+  }, label ? /*#__PURE__*/React.createElement("div", {
+    className: "biz-user-condition-type-label"
+  }, label) : null, /*#__PURE__*/React.createElement("ul", {
+    className: "biz-user-condition-type-container"
+  }, /*#__PURE__*/React.createElement("li", {
+    className: "condition-type",
+    onClick: function onClick() {
+      return onAdd('event');
+    }
+  }, /*#__PURE__*/React.createElement(Space, null, /*#__PURE__*/React.createElement(PlusOutlined, null), /*#__PURE__*/React.createElement("span", null, "\u505A\u8FC7\uFF08\u6CA1\u505A\u8FC7\uFF09\u2026"))), /*#__PURE__*/React.createElement("li", {
+    className: "condition-type",
+    onClick: function onClick() {
+      return onAdd('add');
+    }
+  }, /*#__PURE__*/React.createElement(Space, null, /*#__PURE__*/React.createElement(PlusOutlined, null), /*#__PURE__*/React.createElement("span", null, "\u65B0\u589E\u4E8E"))), /*#__PURE__*/React.createElement("li", {
+    className: "condition-type",
+    onClick: function onClick() {
+      return onAdd('active');
+    }
+  }, /*#__PURE__*/React.createElement(Space, null, /*#__PURE__*/React.createElement(PlusOutlined, null), /*#__PURE__*/React.createElement("span", null, "\u6D3B\u8DC3\u4E8E"))), /*#__PURE__*/React.createElement("li", {
+    className: "condition-type",
+    onClick: function onClick() {
+      return onAdd('prop');
+    }
+  }, /*#__PURE__*/React.createElement(Space, null, /*#__PURE__*/React.createElement(PlusOutlined, null), /*#__PURE__*/React.createElement("span", null, "\u7528\u6237\u5C5E\u6027\u6EE1\u8DB3")))));
+};
+
+ConditionTypeList.defaultProps = {
+  show: true
+};
+export default ConditionTypeList;

package/es/userCondition/conditionWrap.d.ts

@@ -0,0 +1,7 @@
+import React, { PropsWithChildren } from 'react';
+import './styles/conditionWrap.less';
+export interface ConditionWrapPropsI {
+    onDelte: () => void;
+}
+declare const ConditionWrap: React.FC<PropsWithChildren<ConditionWrapPropsI>>;
+export default ConditionWrap;

package/es/userCondition/conditionWrap.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { CloseOutlined } from '@ant-design/icons';
+import './styles/conditionWrap.less';
+
+var ConditionWrap = function ConditionWrap(props) {
+  return /*#__PURE__*/React.createElement("div", {
+    className: "biz-user-condition-item-wrap"
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "biz-user-condition-item"
+  }, props.children), /*#__PURE__*/React.createElement("div", {
+    className: "biz-user-condition-item-delete",
+    onClick: function onClick() {
+      return props.onDelte();
+    }
+  }, /*#__PURE__*/React.createElement(CloseOutlined, null)));
+};
+
+export default ConditionWrap;

package/es/userCondition/conditions/eventCondition.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { AllConditionBasePropsI, BizUserConditionT } from '../types';
+import './styles/eventCondition.less';
+export interface EventConditionPropsI extends AllConditionBasePropsI<any> {
+    condition: BizUserConditionT.EventCondition;
+}
+declare const EventCondition: React.FC<EventConditionPropsI>;
+export default EventCondition;

package/es/userCondition/conditions/eventCondition.js

@@ -0,0 +1,104 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+import React from 'react';
+import { RightOutlined } from '@ant-design/icons';
+import BizEventSelector from '../../eventSelector';
+import RunTimesCondition from './runTimesCondition';
+import PeriodCondition from './periodCondition';
+import PropCondition from './propCondition';
+import './styles/eventCondition.less';
+import { classPrefix } from '..';
+
+var EventCondition = function EventCondition(props) {
+  var condition = props.condition,
+      dataId = props.dataId;
+
+  function onChange(data) {
+    props.onChange(dataId, data);
+  }
+
+  function onEventChange(data) {
+    var event = data.event;
+    onChange(_objectSpread(_objectSpread({}, condition), {}, {
+      eventId: event.id
+    }));
+  }
+
+  function onRunTimesChange(newRunTimes) {
+    onChange(_objectSpread(_objectSpread({}, condition), {}, {
+      runTimes: newRunTimes
+    }));
+  }
+
+  function onPeriodChange(_dataId, newPeriod) {
+    onChange(_objectSpread(_objectSpread({}, condition), {}, {
+      runPeriod: newPeriod
+    }));
+  }
+
+  function onAttrChange(_dataId, newAttrs) {
+    onChange(_objectSpread(_objectSpread({}, condition), {}, {
+      attrs: newAttrs
+    }));
+  }
+
+  function onAddAttr() {
+    onChange(_objectSpread(_objectSpread({}, condition), {}, {
+      attrs: [{
+        attrId: 0,
+        attrName: ''
+      }]
+    }));
+  }
+
+  return /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-event-condition")
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-event-condition-left")
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-event-condition-label")
+  }, /*#__PURE__*/React.createElement("span", null, "\u505A\u8FC7")), /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-event")
+  }, /*#__PURE__*/React.createElement(BizEventSelector, {
+    showAllEvent: false,
+    defaultValue: {
+      event: {
+        id: condition.eventId
+      }
+    },
+    onChange: onEventChange
+  })), /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-event-condition-expand-attr"),
+    onClick: onAddAttr
+  }, /*#__PURE__*/React.createElement(RightOutlined, null))), /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-event-condition-right")
+  }, condition.attrs.length && condition.eventId ? /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-event-condition-attrs")
+  }, /*#__PURE__*/React.createElement(PropCondition, {
+    isEvent: true,
+    dataId: dataId,
+    attrs: condition.attrs,
+    onChange: onAttrChange,
+    eventId: condition.eventId
+  })) : null, /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-event-condition-times-period-wrap")
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-event-condition-runtimes")
+  }, /*#__PURE__*/React.createElement(RunTimesCondition, {
+    onChange: onRunTimesChange,
+    runTimes: condition.runTimes
+  })), /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-event-condition-period")
+  }, /*#__PURE__*/React.createElement(PeriodCondition, {
+    dataId: dataId,
+    runPeriod: condition.runPeriod,
+    onChange: onPeriodChange,
+    isEvent: true
+  })))));
+};
+
+export default EventCondition;

package/es/userCondition/conditions/periodCondition.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { AllConditionBasePropsI, RunPeriodI } from '../types';
+import './styles/periodCondition.less';
+export interface PeriodConditionPropsI extends AllConditionBasePropsI<RunPeriodI> {
+    label?: string | React.ReactDOM;
+    isEvent?: boolean;
+    runPeriod: RunPeriodI;
+    isRealTime?: boolean;
+}
+declare const PeriodCondition: React.FC<PeriodConditionPropsI>;
+export default PeriodCondition;

package/es/userCondition/conditions/periodCondition.js

@@ -0,0 +1,156 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+import React from 'react';
+import BizSelect from '../../select';
+import { Input, DatePicker, Checkbox } from 'antd';
+import moment from 'moment';
+import './styles/periodCondition.less';
+import { classPrefix } from '..';
+var RangePicker = DatePicker.RangePicker;
+var operatorMap = {
+  relative: '最近',
+  absolute: '固定时段',
+  unlimited_time: '任意时间',
+  join_time: '新增后'
+};
+
+var PeriodCondition = function PeriodCondition(props) {
+  var dataId = props.dataId,
+      label = props.label,
+      isEvent = props.isEvent,
+      runPeriod = props.runPeriod;
+  var options = [{
+    text: '最近',
+    value: 'relative'
+  }, {
+    text: '固定时段',
+    value: 'absolute'
+  }];
+
+  if (isEvent) {
+    options = options.concat([{
+      text: '任意时间',
+      value: 'unlimited_time'
+    }, {
+      text: '新增后',
+      value: 'join_time'
+    }]);
+  }
+
+  function onChange(data) {
+    props.onChange(dataId, data);
+  }
+
+  function onOperatorChange(option) {
+    var newData = {
+      operator: option.value
+    };
+
+    if (newData.operator === 'absolute') {
+      var endDate = moment().format('YYYY-MM-DD');
+      var startDate = moment().subtract(7, 'days').format('YYYY-MM-DD');
+      newData.values = [startDate, endDate];
+    }
+
+    if (newData.operator === 'relative') {
+      newData.values = ['30', '0'];
+    }
+
+    if (newData.operator === 'join_time') {
+      newData.values = ['3', '0'];
+    }
+
+    onChange(newData);
+  }
+
+  function onDateChange(newData) {
+    if (runPeriod.operator === 'absolute') {
+      var dateRange = newData;
+      var newValues = dateRange.map(function (date) {
+        return date.format('YYYY-MM-DD');
+      });
+      onChange(_objectSpread(_objectSpread({}, runPeriod), {}, {
+        values: newValues
+      }));
+    } else if (runPeriod.operator === 'relative' || runPeriod.operator === 'join_time') {
+      var newValue = newData.target.value;
+      onChange(_objectSpread(_objectSpread({}, runPeriod), {}, {
+        values: [newValue, runPeriod.values[1]]
+      }));
+    }
+  }
+
+  function onChangeToday(e) {
+    var newValues = [runPeriod.values[0], '0'];
+
+    if (e.target.checked) {
+      newValues[1] = '1';
+      console.log(newValues);
+    }
+
+    onChange(_objectSpread(_objectSpread({}, runPeriod), {}, {
+      values: newValues
+    }));
+  }
+
+  function renderValues() {
+    var operator = runPeriod.operator,
+        values = runPeriod.values;
+
+    if (operator === 'relative' || operator === 'join_time') {
+      return /*#__PURE__*/React.createElement(Input, {
+        size: "large",
+        value: values[0],
+        onChange: onDateChange,
+        style: {
+          width: 58
+        }
+      });
+    }
+
+    if (operator === 'absolute') {
+      return /*#__PURE__*/React.createElement(RangePicker, {
+        defaultValue: [moment(values[0]), moment(values[1])],
+        onChange: onDateChange,
+        allowClear: false
+      });
+    }
+  }
+
+  return /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-period-condition")
+  }, label ? /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-period-condition-label")
+  }, label) : null, /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-period-condition-operator")
+  }, /*#__PURE__*/React.createElement(BizSelect, {
+    overlayWidth: 129,
+    options: options,
+    labelField: "text",
+    keyField: "value",
+    value: {
+      value: runPeriod.operator,
+      text: operatorMap[runPeriod.operator]
+    },
+    onChange: onOperatorChange
+  })), /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-period-condition-values")
+  }, renderValues()), /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-period-condition-unit")
+  }, "\u5929"), props.isRealTime && runPeriod.operator === 'relative' ? /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-period-condition-today")
+  }, /*#__PURE__*/React.createElement(Checkbox, {
+    checked: runPeriod.values[1] === '1',
+    onChange: onChangeToday
+  }, "\u4E0D\u5305\u542B\u4ECA\u5929")) : null);
+};
+
+PeriodCondition.defaultProps = {
+  isEvent: false,
+  isRealTime: false
+};
+export default PeriodCondition;

package/es/userCondition/conditions/propCondition.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { PropConditionType } from '../types';
+import './styles/propCondition.less';
+declare const PropCondition: React.FC<PropConditionType.PropsI>;
+export default PropCondition;

package/es/userCondition/conditions/propCondition.js

@@ -0,0 +1,198 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _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, useState } from 'react';
+import { PlusOutlined } from '@ant-design/icons';
+import BizConditionItem from '../../attrConditions';
+import './styles/propCondition.less';
+import { useContext } from 'react';
+import { BizUserConditionContext, classPrefix } from '..';
+import { transformNumberOperate } from '../util';
+var numAttrTypeMap = {
+  1: 'cont-string',
+  2: 'cont-num',
+  3: 'cont-date'
+};
+var attrNumTypeMap = {
+  'cont-string': 1,
+  'cont-num': 2,
+  'cont-date': 3
+};
+
+var PropCondition = function PropCondition(props) {
+  var _useContext = useContext(BizUserConditionContext),
+      eventAttrNum = _useContext.eventAttrNum;
+
+  var isEvent = props.isEvent,
+      label = props.label,
+      attrs = props.attrs,
+      dataId = props.dataId;
+
+  var _useState = useState([]),
+      _useState2 = _slicedToArray(_useState, 2),
+      showList = _useState2[0],
+      setShowList = _useState2[1];
+
+  JSON.stringify(showList);
+  useEffect(function () {
+    buildDefault();
+  }, []);
+
+  function buildDefault() {
+    var list = [];
+    attrs.forEach(function (attr) {
+      var attrId = attr.attrId,
+          attrName = attr.attrName,
+          operator = attr.operator;
+
+      if ((attrName || attrId) && operator) {
+        attr.operator = transformNumberOperate(operator, false);
+        list.push({
+          attr: attr,
+          default: attr,
+          id: Math.random()
+        });
+      } else {
+        list.push({
+          attr: attr,
+          id: Math.random()
+        });
+      }
+    });
+    setShowList(list);
+  }
+
+  function _onChange(data, i) {
+    var attrName = data.attrName,
+        attrId = data.attrId,
+        category = data.category,
+        type = data.type,
+        operation = data.operation,
+        values = data.values;
+
+    var newAttrs = _toConsumableArray(attrs);
+
+    var newAttr = {
+      attrName: attrName,
+      attrId: attrId,
+      category: category,
+      operator: transformNumberOperate(operation),
+      params: values,
+      attrType: numAttrTypeMap[type]
+    };
+    Object.assign(newAttrs[i], newAttr);
+    props.onChange(dataId, newAttrs);
+  }
+
+  function onAddAttr() {
+    var attr = {
+      attrId: 0
+    };
+    setShowList([].concat(_toConsumableArray(showList), [{
+      id: Math.random(),
+      attr: attr
+    }]));
+    props.onChange(dataId, [].concat(_toConsumableArray(attrs), [attr]));
+  }
+
+  function onRemoveAttr(i) {
+    var newAttrs = _toConsumableArray(attrs);
+
+    var newList = _toConsumableArray(showList);
+
+    newList.splice(i, 1);
+    newAttrs.splice(i, 1);
+    setShowList(newList);
+    props.onChange(dataId, newAttrs);
+  }
+
+  function getPropCategory(attrName) {
+    if (!isEvent) return 'userProp';
+    return attrName === undefined ? 'eventProp' : 'envProp';
+  }
+
+  function renderAttr(item, i) {
+    var props = {};
+    var id = item.id;
+
+    if (item.default) {
+      var _item$default = item.default,
+          attrId = _item$default.attrId,
+          attrName = _item$default.attrName,
+          category = _item$default.category,
+          operator = _item$default.operator,
+          params = _item$default.params,
+          attrType = _item$default.attrType;
+      props.defaultValue = {
+        attrName: attrName,
+        category: category || 'custom',
+        operation: operator,
+        values: params || [],
+        propCategory: getPropCategory(attrName),
+        type: attrNumTypeMap[attrType]
+      };
+      attrId && (props.defaultValue.attrId = attrId);
+    }
+
+    return /*#__PURE__*/React.createElement("div", {
+      className: "".concat(classPrefix, "-prop-condition-attr"),
+      key: id
+    }, /*#__PURE__*/React.createElement("div", {
+      className: "".concat(classPrefix, "-prop-condition-item-wrap")
+    }, /*#__PURE__*/React.createElement(BizConditionItem, _objectSpread({
+      onChange: function onChange(data) {
+        return _onChange(data, i);
+      },
+      enableUserProp: !isEvent,
+      enableEnvProp: isEvent,
+      enableEventProp: isEvent,
+      onDelete: function onDelete() {
+        return onRemoveAttr(i);
+      },
+      enableDelete: isEvent
+    }, props))));
+  }
+
+  return /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-prop-condition")
+  }, label ? /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-prop-condition-label")
+  }, label) : null, /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-prop-condition-attrs")
+  }, showList && showList.map(function (item, i) {
+    return renderAttr(item, i);
+  })), attrs.length < eventAttrNum && isEvent ? /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-prop-condition-add")
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-prop-add-btn"),
+    onClick: onAddAttr
+  }, /*#__PURE__*/React.createElement(PlusOutlined, null))) : null);
+};
+
+PropCondition.defaultProps = {
+  isEvent: false
+};
+export default PropCondition;

package/es/userCondition/conditions/runTimesCondition.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { RunTimesI } from '../types';
+import './styles/runTimesCondition.less';
+export interface RunTimesConditionPropsI {
+    runTimes: RunTimesI;
+    onChange: (data: RunTimesI) => void;
+}
+declare const RunTimesCondition: React.FC<RunTimesConditionPropsI>;
+export default RunTimesCondition;

package/es/userCondition/conditions/runTimesCondition.js

@@ -0,0 +1,78 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+import React from 'react';
+import { Input, Tooltip, Space } from 'antd';
+import { InfoCircleOutlined } from '@ant-design/icons';
+import BizSelect from '../../select';
+import './styles/runTimesCondition.less';
+import { classPrefix } from '..';
+var options = [{
+  value: '>',
+  text: '>'
+}, {
+  value: '=',
+  text: '='
+}, {
+  value: '<',
+  text: '<'
+}, {
+  value: '>=',
+  text: '>='
+}, {
+  value: '<=',
+  text: '<='
+}, {
+  value: 'not equal',
+  text: '≠'
+}];
+
+var RunTimesCondition = function RunTimesCondition(props) {
+  var runTimes = props.runTimes,
+      onChange = props.onChange;
+
+  function onOperatorChange(data) {
+    onChange(_objectSpread(_objectSpread({}, runTimes), {}, {
+      operator: data.value
+    }));
+  }
+
+  function onValueChange(e) {
+    var value = e.target.value;
+    onChange(_objectSpread(_objectSpread({}, runTimes), {}, {
+      values: [value]
+    }));
+  }
+
+  return /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-runtimes-condition")
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-runtimes-condition-operator")
+  }, /*#__PURE__*/React.createElement(BizSelect, {
+    options: options,
+    labelField: "text",
+    keyField: "value",
+    value: {
+      value: runTimes.operator,
+      text: runTimes.operator === 'not equal' ? '≠' : runTimes.operator
+    },
+    onChange: onOperatorChange
+  })), /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-runtimes-condition-value")
+  }, /*#__PURE__*/React.createElement(Input, {
+    size: "large",
+    value: runTimes.values[0],
+    onChange: onValueChange
+  })), /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-runtimes-condition-unit")
+  }, /*#__PURE__*/React.createElement(Space, null, "\u6B21", /*#__PURE__*/React.createElement(Tooltip, {
+    title: "\u89E6\u53D1\u6B21\u6570\u4E3A0\u7B49\u540C\u4E8E\u6CA1\u6709\u89E6\u53D1"
+  }, /*#__PURE__*/React.createElement("span", {
+    className: "".concat(classPrefix, "-runtimes-tip")
+  }, /*#__PURE__*/React.createElement(InfoCircleOutlined, null))))));
+};
+
+export default RunTimesCondition;