@zgfe/business-lib 1.0.18 → 1.0.19

package/es/userCondition/styles/orConditions.less

@@ -1,13 +1,31 @@
 @import '../../assets/styles/variable.less';
 .biz-user-condition-or {
-  margin-bottom: @margin-md;
+  &:not(:last-child) {
+    margin-bottom: @margin-lg;
+  }
+  &.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%;
-    margin-bottom: @margin-md;
+
     background: #ffffff;
     border: 1px solid @border-color-base;
     border-radius: @border-radius-small;
+    &:not(:last-child) {
+      margin-bottom: @margin-md;
+    }
     .biz-user-condition-conditions {
       flex: 1;
       padding: @padding-xs @padding-md 0 0;

package/es/userCondition/styles/relationLabel.less

@@ -1,9 +1,9 @@
-@import '../../commonStyle/variable.less';
+@import '../../assets/styles/inner.less';
 .biz-user-condition-relation {
   position: relative;
   width: 2px;
-  margin-right: 30px;
-  background-color: @hoverBgColor;
+  margin-right: @margin-lg;
+  background-color: @border-color-split;
   &-label {
     position: absolute;
     top: 50%;
@@ -12,7 +12,8 @@
     height: 24px;
     line-height: 24px;
     text-align: center;
-    background-color: @hoverBgColor;
+    background-color: @border-color-split;
+    border-radius: @border-radius-small;
     transform: translate(-50%, -50%);
   }
 }

package/es/userCondition/types.d.ts

@@ -1,4 +1,6 @@
 /// <reference types="react" />
+import { UserProp } from '../attributeSelector/types';
+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 +17,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,22 +60,38 @@ 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;
         orConditions: Conditions[number];
     }
     type ShowListT = ShowItemI[];
+    type GlobalContext = Pick<BizUserConditionT.PropsI, 'orConditionNum' | 'eventAttrNum' | 'openTagCondition' | 'userTagsData' | 'textMode' | 'isRealTime'> & {
+        envNameList: string[];
+        userPropsMap: {
+            [key: string]: UserProp;
+        };
+    };
 }
 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 + id + id + 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.js';
+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;

package/es/userTagsSelector/groups/index.js

@@ -0,0 +1,86 @@
+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, { useMemo } from 'react';
+import VirtualList from 'rc-virtual-list';
+import { classPrefix } from '../';
+import GroupOption from './groupOption';
+import Search from '../components/search/index';
+import { useState } from 'react';
+import { filterFactory, isCheckedFactory } from '../util';
+
+var Groups = function Groups(props) {
+  var data = props.data,
+      labelField = props.labelField,
+      childField = props.childField,
+      keyField = props.keyField,
+      valueField = props.valueField,
+      searchable = props.searchable,
+      level = props.level,
+      currentValue = props.currentValue;
+
+  var _useState = useState(''),
+      _useState2 = _slicedToArray(_useState, 2),
+      searchValue = _useState2[0],
+      setSearchValue = _useState2[1];
+
+  var _useState3 = useState(data[0][valueField]),
+      _useState4 = _slicedToArray(_useState3, 2),
+      active = _useState4[0],
+      setActive = _useState4[1];
+
+  function _onClick(i) {
+    setActive(data[i][valueField]);
+    props.onActive(data[i], level);
+  }
+
+  function onSearch(val) {
+    setSearchValue(val);
+  }
+
+  var searchFilter = useMemo(function () {
+    return filterFactory(labelField, searchValue);
+  }, [labelField, searchValue]);
+  var isChecked = useMemo(function () {
+    return isCheckedFactory(currentValue, level);
+  }, [currentValue, level]);
+  if (!data.length) return /*#__PURE__*/React.createElement("span", null, "\u6682\u65E0\u6570\u636E");
+  return /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-groups-panel")
+  }, /*#__PURE__*/React.createElement(Search, {
+    show: searchable,
+    onChange: onSearch
+  }), /*#__PURE__*/React.createElement(VirtualList, {
+    data: searchable ? data.filter(searchFilter) : data,
+    height: 408,
+    itemKey: keyField
+  }, function (item, index) {
+    return /*#__PURE__*/React.createElement(GroupOption, {
+      onClick: function onClick() {
+        return _onClick(index);
+      },
+      actived: item[valueField] === active,
+      checked: isChecked(item[valueField]),
+      count: item[childField].length,
+      label: item[labelField],
+      value: item[valueField],
+      highlightText: searchValue
+    });
+  }));
+};
+
+Groups.defaultProps = {
+  data: [],
+  childField: 'children',
+  searchable: false
+};
+export default Groups;

package/es/userTagsSelector/groups/styles/option.less

@@ -0,0 +1,50 @@
+@import '../../../assets/styles/inner.less';
+.biz-user-tags-selector {
+  &-group-option {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    height: 48px;
+    padding: 0 16px;
+    border-radius: @border-radius-normal;
+
+    cursor: pointer;
+    &-label {
+      .__default-overflow();
+      margin-right: @margin-xs;
+    }
+    &-count {
+      .ant-badge-count {
+        color: @text-color;
+        background: none;
+      }
+    }
+    &.checked {
+      color: @primary-color;
+      .biz-user-tags-selector-group-option-count {
+        .ant-badge-count {
+          color: @primary-color;
+        }
+      }
+    }
+    &:hover {
+      .__default-hover();
+      .biz-user-tags-selector-group-option-count {
+        .ant-badge-count {
+          color: #fff;
+          background: @primary-color;
+        }
+      }
+    }
+    &.active {
+      color: #fff;
+      background: @primary-color;
+      .biz-user-tags-selector-group-option-count {
+        .ant-badge-count {
+          color: #fff;
+          background: @primary-color;
+        }
+      }
+    }
+  }
+}

package/es/userTagsSelector/index.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import './styles/index.less';
+import { UserTagsSelectorTypes } from './types';
+export declare const classPrefix = "biz-user-tags-selector";
+declare const UserTagsSelect: React.FC<UserTagsSelectorTypes.Props>;
+export default UserTagsSelect;