@zgfe/business-lib 1.0.14 → 1.0.15-user.1

package/es/userCondition/orConditions.js

@@ -29,13 +29,18 @@ import { buildCondition } from './util';
 import ConditionWrap from './conditionWrap';
 import PropCondition from './conditions/propCondition';
 import EventCondition from './conditions/eventCondition';
+import TagsCondition from './conditions/tagsCondition';
 import { classPrefix } from '.';
+import Text from './conditions/textDesc';
 
 var OrConditions = function OrConditions(props) {
   var _useContext = useContext(BizUserConditionContext),
-      orConditionNum = _useContext.orConditionNum;
+      orConditionNum = _useContext.orConditionNum,
+      textMode = _useContext.textMode,
+      openTagCondition = _useContext.openTagCondition;
 
-  var orConditions = props.orConditions;
+  var orConditions = props.orConditions,
+      showAndDesc = props.showAndDesc;
 
   var _useState = useState([]),
       _useState2 = _slicedToArray(_useState, 2),
@@ -117,6 +122,31 @@ var OrConditions = function OrConditions(props) {
     props.onChange(newValue);
   }
 
+  function onChangeTags(id, newTags) {
+    changeData('tag', id, newTags);
+  }
+
+  function changeData(type, id, newData) {
+    var newValue = [];
+    showList.forEach(function (data) {
+      if (id === data.id) {
+        if (type === 'period') {
+          data.condition.runPeriod = newData;
+        } else if (type === 'attr') {
+          data.condition.attrs = newData;
+        } else if (type === 'event') {
+          data.condition = newData;
+        } else if (type === 'tag') {
+          data.condition.labels = newData;
+        }
+      }
+
+      newValue.push(data.condition);
+    });
+    setShowList(_toConsumableArray(showList));
+    props.onChange(newValue);
+  }
+
   function onDelete(id) {
     var index = showList.findIndex(function (item) {
       return item.id === id;
@@ -133,30 +163,49 @@ var OrConditions = function OrConditions(props) {
     props.onChange(newValue);
   }
 
-  function renderCondition(data) {
+  if (textMode) {
+    return /*#__PURE__*/React.createElement(React.Fragment, null, textMode && showAndDesc ? /*#__PURE__*/React.createElement("span", {
+      className: "".concat(classPrefix, "-and-desc")
+    }, "\u4E14") : null, /*#__PURE__*/React.createElement("span", null, "("), showList.map(function (item, i) {
+      return renderCondition(item, i);
+    }), /*#__PURE__*/React.createElement("span", null, ")"));
+  }
+
+  function renderCondition(data, i) {
     var condition = data.condition,
         id = data.id;
     var conditionDom = null;
 
-    if (condition.eventId === undefined) {
+    if (textMode) {
+      return /*#__PURE__*/React.createElement(Text, {
+        showOrDesc: i > 0,
+        key: i,
+        condition: condition
+      });
+    }
+
+    if (condition.labels) {
+      if (!openTagCondition) return null;
+      conditionDom = /*#__PURE__*/React.createElement(TagsCondition, {
+        labels: condition.labels,
+        dataId: id,
+        onChange: onChangeTags
+      });
+    } else if (condition.eventId === undefined) {
       conditionDom = /*#__PURE__*/React.createElement(PropCondition, {
         label: "\u5C5E\u6027",
         attrs: condition.attrs,
         dataId: id,
         onChange: onChangeAttrs
       });
-    }
-
-    if (condition.eventId === '-3') {
+    } else if (condition.eventId === '-3') {
       conditionDom = /*#__PURE__*/React.createElement(PeriodCondition, {
         label: "\u65B0\u589E\u4E8E",
         dataId: id,
         onChange: onChangeRunPeriod,
         runPeriod: condition.runPeriod
       });
-    }
-
-    if (condition.eventId === '-4') {
+    } else if (condition.eventId === '-4') {
       conditionDom = /*#__PURE__*/React.createElement(PeriodCondition, {
         label: "\u6D3B\u8DC3\u4E8E",
         isRealTime: true,
@@ -164,9 +213,7 @@ var OrConditions = function OrConditions(props) {
         onChange: onChangeRunPeriod,
         runPeriod: condition.runPeriod
       });
-    }
-
-    if (util.isNumber(condition.eventId)) {
+    } else if (util.isNumber(condition.eventId)) {
       conditionDom = /*#__PURE__*/React.createElement(EventCondition, {
         dataId: id,
         onChange: onChangeEvent,
@@ -183,15 +230,15 @@ var OrConditions = function OrConditions(props) {
   }
 
   return /*#__PURE__*/React.createElement("div", {
-    className: "".concat(classPrefix, "-or")
+    className: ["".concat(classPrefix, "-or"),, textMode ? 'text-mode' : ''].join(' ')
   }, /*#__PURE__*/React.createElement("div", {
-    className: "".concat(classPrefix, "-or-content")
+    className: ["".concat(classPrefix, "-or-content")].join(' ')
   }, /*#__PURE__*/React.createElement(RelationLabel, {
     show: showList.length >= 2
   }, "\u6216"), /*#__PURE__*/React.createElement("div", {
     className: "".concat(classPrefix, "-conditions")
-  }, showList.map(function (item) {
-    return renderCondition(item);
+  }, showList.map(function (item, i) {
+    return renderCondition(item, i);
   }))), /*#__PURE__*/React.createElement(ConditionTypeList, {
     label: "\u6216",
     onAdd: onAdd,

package/es/userCondition/relationLabel.js

@@ -1,7 +1,12 @@
-import React from 'react';
+import React, { useContext } from 'react';
+import { BizUserConditionContext } from '.';
 import './styles/relationLabel.less';
 
 var RelationLabel = function RelationLabel(props) {
+  var _useContext = useContext(BizUserConditionContext),
+      textMode = _useContext.textMode;
+
+  if (textMode) return null;
   return /*#__PURE__*/React.createElement("div", {
     className: "biz-user-condition-relation"
   }, props.show ? /*#__PURE__*/React.createElement("div", {

package/es/userCondition/styles/conditionTypeList.less

@@ -13,7 +13,7 @@
     list-style: none;
     .condition-type {
       padding: @padding-xss 12px;
-      border: 1px solid @border-color-base;
+      background-color: @background-color-base;
       border-radius: @border-radius-large;
       cursor: pointer;
       &:nth-child(n + 2) {

package/es/userCondition/styles/conditionWrap.less

@@ -8,6 +8,9 @@
     flex: 1;
   }
   .biz-user-condition-item-delete {
+    display: flex;
+    align-items: center;
+    height: 40px;
     margin-left: @margin-lg;
     cursor: pointer;
   }

package/es/userCondition/styles/index.less

@@ -1,13 +1,32 @@
 @import '../../assets/styles/variable.less';
 .biz-user-condition {
+  width: 100%;
+  min-width: 0;
   &-conditions-content {
     display: flex;
     .biz-user-condition-and-conditions-wrap {
       flex: 1;
       margin-bottom: @margin-md;
+      &.text-mode {
+        display: flex;
+        flex-wrap: wrap;
+        min-width: 0;
+        margin-bottom: 0;
+        border: none;
+        .biz-user-condition-and-desc {
+          margin: 0 @margin-xs;
+        }
+      }
     }
     .biz-user-condition-and-conditions-empty {
       margin-bottom: 0;
     }
+    .biz-select-handle-input-multiple {
+      min-height: 40px;
+      padding: calc(@margin-xs - 2px) @margin-xs calc(@margin-xs - 2px) @margin-sm;
+      .biz-select-handle-holder {
+        line-height: 28px;
+      }
+    }
   }
 }

package/es/userCondition/styles/orConditions.less

@@ -1,6 +1,19 @@
 @import '../../assets/styles/variable.less';
 .biz-user-condition-or {
   margin-bottom: @margin-md;
+  &.text-mode {
+    display: flex;
+    min-width: 0;
+    // align-items: center;
+    margin-bottom: 0;
+    .biz-user-condition-or-content {
+      margin-bottom: 0;
+      border: none;
+      .biz-user-condition-conditions {
+        padding: 0;
+      }
+    }
+  }
   &-content {
     display: flex;
     width: 100%;

package/es/userCondition/types.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="react" />
+import { TagI } from './../userTagsSelector/types';
 export declare type Unpacked<T, U extends keyof T> = Required<T> extends {
     [key in U]: infer R;
 } ? R : never;
@@ -15,13 +16,21 @@ export interface AllConditionBasePropsI<T> {
     onChange: (dataId: number, newData: T) => void;
 }
 export declare namespace BizUserConditionT {
-    type ConditionType = 'add' | 'active' | 'event' | 'prop';
+    type ConditionType = 'add' | 'active' | 'event' | 'prop' | 'tag';
     interface PropsI {
         defaultValue: BizUserConditionT.Conditions;
         onChange: (value: any[]) => void;
         andConditionNum?: number;
         orConditionNum?: number;
         eventAttrNum?: number;
+        textMode?: boolean;
+        openTagCondition?: boolean;
+        userTagsData?: UserTagsDataI[];
+        isRealTime?: boolean;
+    }
+    interface UserTagsDataI {
+        labelGroup: string;
+        children: TagI[];
     }
     interface AttrCondition {
         attrId: number;
@@ -50,11 +59,20 @@ export declare namespace BizUserConditionT {
         runPeriod: RunPeriodI;
         runTimes: RunTimesI;
     }
+    interface Labels {
+        operator: 'not equal' | 'equal';
+        values: number[];
+    }
+    interface TagsCondition {
+        attrs: [];
+        labels: Labels;
+        eventId: undefined;
+    }
     interface PropCondition {
         attrs: AttrCondition[];
         eventId: undefined;
     }
-    type Condition = EventCondition | AddCondition | ActiveCondition | PropCondition;
+    type Condition = EventCondition | AddCondition | ActiveCondition | PropCondition | TagsCondition;
     type Conditions = Condition[][];
     interface ShowItemI {
         id: number;
@@ -66,6 +84,7 @@ export declare namespace OrConditionsT {
     interface PropI {
         onChange: (value: any[]) => void;
         orConditions: BizUserConditionT.Conditions[number];
+        showAndDesc: boolean;
     }
     interface ShowItemI {
         id: number;

package/es/userCondition/util.d.ts

@@ -1,3 +1,7 @@
-import { BizUserConditionT } from './types';
+import type { GlobalContextProps } from '../context';
+import type { BizUserConditionT, Unpacked } from './types';
 export declare function buildCondition(type: BizUserConditionT.ConditionType): BizUserConditionT.EventCondition | BizUserConditionT.AddCondition | BizUserConditionT.ActiveCondition | BizUserConditionT.PropCondition;
 export declare function transformNumberOperate(key: string, output?: boolean): string;
+export declare function findEvent(eventId: number, eventGroupList: Unpacked<GlobalContextProps, 'eventGroupList'>): import("../attributeSelector/types").AnalysisEvent | null;
+export declare function findPropAndEnv(name: string, list: Unpacked<GlobalContextProps, 'userPropList' | 'eventEnvList'>): import("../attributeSelector/types").UserProp | import("../attributeSelector/types").EnvProp | null;
+export declare function findTagFactory(data: BizUserConditionT.UserTagsDataI[]): (id: number) => import("../userTagsSelector/types").TagI | null;

package/es/userCondition/util.js

@@ -50,6 +50,16 @@ export function buildCondition(type) {
           attrId: 0
         }]
       };
+
+    case 'tag':
+      return {
+        attrs: [],
+        labels: {
+          operator: 'equal',
+          values: []
+        },
+        eventId: undefined
+      };
   }
 }
 export function transformNumberOperate(key) {
@@ -70,4 +80,36 @@ export function transformNumberOperate(key) {
   };
   if (output) return outputMap[key] || key;
   return inputMap[key] || key;
+}
+export function findEvent(eventId, eventGroupList) {
+  for (var i = 0; i < eventGroupList.length; i++) {
+    var eventList = eventGroupList[i].eventList;
+
+    for (var j = 0; j < eventList.length; j++) {
+      if (eventList[j].id === eventId) return eventList[j];
+    }
+  }
+
+  return null;
+}
+export function findPropAndEnv(name, list) {
+  for (var i = 0; i < list.length; i++) {
+    if (list[i].name === name) return list[i];
+  }
+
+  return null;
+}
+export function findTagFactory(data) {
+  return function (id) {
+    var i = -1;
+    var j = data.findIndex(function (item) {
+      i = item.children.findIndex(function (tag) {
+        return tag.labelId === id;
+      });
+      if (i < 0) return false;
+      return true;
+    });
+    if (j < 0) return null;
+    return data[j].children[i];
+  };
 }

package/es/userTagsSelector/cascaderOverlay.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import './styles/cascaderOverlay.less';
+import { UserTagsSelectorTypes } from './types';
+declare const CascaderOverlay: React.FC<UserTagsSelectorTypes.CascaderOverlayProps>;
+export default CascaderOverlay;

package/es/userTagsSelector/cascaderOverlay.js

@@ -0,0 +1,114 @@
+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 from 'react';
+import { useState } from 'react';
+import { classPrefix } from '.';
+import './styles/cascaderOverlay.less';
+import Groups from './groups/index';
+import MultipleCheckPanel from './multipleCheckPanel';
+import { getFieldFactory } from './util';
+import _ from 'lodash';
+
+var CascaderOverlay = function CascaderOverlay(props) {
+  var data = props.data,
+      currentValue = props.currentValue,
+      labelFields = props.labelFields,
+      keyFields = props.keyFields,
+      valueFields = props.valueFields,
+      childFields = props.childFields;
+
+  var _useState = useState(function () {
+    var initPath = [];
+    var curr = data[0];
+    var getChildField = getFieldFactory(childFields);
+
+    while (curr) {
+      initPath.push(curr);
+      curr = curr[getChildField()];
+    }
+
+    initPath.pop();
+    return initPath;
+  }),
+      _useState2 = _slicedToArray(_useState, 2),
+      currentPath = _useState2[0],
+      setCurrentPath = _useState2[1];
+
+  function onActive(data, level) {
+    var currIndex = level;
+    var getChildField = getFieldFactory(childFields.slice(currIndex).length ? childFields.slice(currIndex) : childFields.slice(-1));
+    var curr = data;
+    var newPath = currentPath.slice();
+
+    while (curr) {
+      newPath[currIndex] = curr;
+      curr = curr[getChildField()];
+      currIndex++;
+    }
+
+    newPath.pop();
+    setCurrentPath(newPath);
+  }
+
+  function onCheck(data) {
+    var getVabelField = getFieldFactory(valueFields);
+    var newValue = currentPath.map(function (item) {
+      return item[getVabelField()];
+    }).concat(data);
+    props.onChange([].concat(_toConsumableArray(currentValue), [newValue]));
+  }
+
+  function onUncheck(data) {
+    var index = currentValue.findIndex(function (item) {
+      return _.isEqual(item.slice().pop(), data);
+    });
+    var newValues = currentValue.slice();
+    newValues.splice(index, 1);
+    props.onChange(newValues);
+  }
+
+  return /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-overlay")
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-overlay-groups")
+  }, /*#__PURE__*/React.createElement(Groups, {
+    currentValue: currentValue,
+    valueField: valueFields[0],
+    keyField: keyFields[0],
+    childField: childFields[0],
+    labelField: labelFields[0],
+    data: data,
+    onActive: onActive,
+    level: 0
+  })), /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-overlay-selections")
+  }, /*#__PURE__*/React.createElement(MultipleCheckPanel, {
+    valueField: valueFields[1],
+    onCheck: onCheck,
+    onUncheck: onUncheck,
+    currentValue: currentValue,
+    level: 1,
+    labelField: labelFields[1],
+    data: currentPath[0][childFields[0]]
+  })));
+};
+
+export default CascaderOverlay;

package/es/userTagsSelector/components/search/index.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import './index.less';
+declare const Search: React.FC<{
+    show: boolean;
+    onChange: (val: string) => void;
+    placeholder?: string;
+}>;
+export default Search;

package/es/userTagsSelector/components/search/index.js

@@ -0,0 +1,16 @@
+import React from 'react';
+import BizSearchInput from '../../../searchInput';
+import './index.less';
+import { classPrefix } from '../..';
+
+var Search = function Search(props) {
+  if (!props.show) return null;
+  return /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-drop-panel-search")
+  }, /*#__PURE__*/React.createElement(BizSearchInput, {
+    placeholder: props.placeholder,
+    onChange: props.onChange
+  }));
+};
+
+export default Search;

package/es/userTagsSelector/components/search/index.less

@@ -0,0 +1,6 @@
+@import '../../../assets/styles/variable.less';
+.biz-user-tags-selector {
+  &-drop-panel-search {
+    margin-bottom: @margin-xs;
+  }
+}

package/es/userTagsSelector/context.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { UserTagsSelectorTypes } from './types';
+export declare const UserTagsSelectContext: import("react").Context<Partial<UserTagsSelectorTypes.Props>>;

package/es/userTagsSelector/context.js

@@ -0,0 +1,2 @@
+import { createContext } from 'react';
+export var UserTagsSelectContext = /*#__PURE__*/createContext({});

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

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

package/es/userTagsSelector/demo/index.js

@@ -0,0 +1,48 @@
+import React from 'react';
+import { BizUserTagsSelect } from '@zgfe/business-lib';
+var data = [{
+  labelGroup: '基本标签',
+  children: []
+}, {
+  labelGroup: '行为标签',
+  children: []
+}, {
+  labelGroup: '活跃标签',
+  children: []
+}, {
+  labelGroup: '预测标签',
+  children: []
+}, {
+  labelGroup: '其它标签',
+  children: []
+}];
+var defaultValue = [];
+data.forEach(function (item) {
+  item.children = Array(100 * Math.random() >> 0).fill(1).map(function (_child, _index) {
+    var id = Math.random();
+    var tag = {
+      id: id,
+      labelName: '标签' + id
+    };
+
+    if (id < 0.6 && defaultValue.length < 20) {
+      defaultValue.push([item.labelGroup, tag]);
+    }
+
+    return tag;
+  });
+});
+export default (function () {
+  function onChange(data) {
+    console.log(data);
+  }
+
+  return /*#__PURE__*/React.createElement(BizUserTagsSelect, {
+    childFields: ['children'],
+    data: data,
+    keyFields: ['labelGroup', 'id'],
+    labelFields: ['labelGroup', 'labelName'],
+    valueFields: ['labelGroup', 'labelId'],
+    onChange: onChange
+  });
+});

package/es/userTagsSelector/groups/groupOption.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { UserTagsSelectorTypes } from '../types';
+import './styles/option.less';
+declare const GroupOption: React.ForwardRefExoticComponent<UserTagsSelectorTypes.GroupOption & React.RefAttributes<HTMLDivElement>>;
+export default GroupOption;

package/es/userTagsSelector/groups/groupOption.js

@@ -0,0 +1,42 @@
+import React, { forwardRef } from 'react';
+import { Badge } from 'antd';
+import { classPrefix } from '..';
+import theme from '../../assets/theme';
+import './styles/option.less';
+import { util } from '../../utils';
+var GroupOption = /*#__PURE__*/forwardRef(function (props, ref) {
+  var label = props.label,
+      count = props.count,
+      actived = props.actived,
+      checked = props.checked,
+      _onClick = props.onClick,
+      value = props.value,
+      highlightText = props.highlightText;
+
+  function renderLabel() {
+    if (!highlightText || !highlightText.trim()) return label;
+    var dom = util.setHighLight(label, highlightText, function (text) {
+      return /*#__PURE__*/React.createElement("span", {
+        style: {
+          color: theme['primary-color']
+        }
+      }, text);
+    });
+    return dom;
+  }
+
+  return /*#__PURE__*/React.createElement("div", {
+    onClick: function onClick() {
+      return _onClick(value);
+    },
+    className: ["".concat(classPrefix, "-group-option"), actived ? 'active' : '', checked ? 'checked' : ''].join(' '),
+    ref: ref
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-group-option-label")
+  }, renderLabel()), /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-group-option-count")
+  }, /*#__PURE__*/React.createElement(Badge, {
+    count: count
+  })));
+});
+export default GroupOption;

package/es/userTagsSelector/groups/index.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { UserTagsSelectorTypes } from '../types';
+declare const Groups: React.FC<UserTagsSelectorTypes.Groups>;
+export default Groups;