@aloudata/aloudata-design 2.12.6 → 2.13.0

package/dist/ColorPicker/index.js

@@ -155,10 +155,10 @@ export default function ColorPicker(_ref) {
     }),
     ref: wrapRef
   }, /*#__PURE__*/React.createElement(Dropdown, {
-    trigger: ['click'],
+    trigger: 'click',
     open: open,
     disabled: disabled,
-    placement: 'bottomLeft',
+    placement: 'bottom-start',
     dropdownRender: function dropdownRender() {
       return overlay;
     }

package/dist/Icon/components/SignLightLine.d.ts

@@ -0,0 +1,11 @@
+import type { SVGProps } from 'react';
+import * as React from 'react';
+interface SVGRProps {
+    size?: number | string;
+    title?: string;
+    titleId?: string;
+    desc?: string;
+    descId?: string;
+}
+declare const Memo: React.MemoExoticComponent<React.ForwardRefExoticComponent<Omit<SVGProps<SVGSVGElement> & SVGRProps, "ref"> & React.RefAttributes<SVGSVGElement>>>;
+export default Memo;

package/dist/Icon/components/SignLightLine.js

@@ -0,0 +1,35 @@
+var _excluded = ["title", "titleId", "desc", "descId"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import * as React from 'react';
+import { forwardRef, memo } from 'react';
+var SignLightLine = function SignLightLine(_ref, ref) {
+  var title = _ref.title,
+    titleId = _ref.titleId,
+    desc = _ref.desc,
+    descId = _ref.descId,
+    props = _objectWithoutProperties(_ref, _excluded);
+  return /*#__PURE__*/React.createElement("svg", _extends({
+    xmlns: "http://www.w3.org/2000/svg",
+    width: props.width || props.size || 16,
+    height: props.height || props.size || 16,
+    fill: "none",
+    viewBox: "0 0 24 24",
+    ref: ref,
+    "aria-labelledby": titleId,
+    "aria-describedby": descId
+  }, props), desc ? /*#__PURE__*/React.createElement("desc", {
+    id: descId
+  }, desc) : null, title ? /*#__PURE__*/React.createElement("title", {
+    id: titleId
+  }, title) : null, /*#__PURE__*/React.createElement("path", {
+    fill: props.color || 'currentColor',
+    fillRule: "evenodd",
+    d: "M12 5.25a.75.75 0 0 1 .75.75v5.25H18a.75.75 0 0 1 0 1.5h-5.25V18a.75.75 0 0 1-1.5 0v-5.25H6a.75.75 0 0 1 0-1.5h5.25V6a.75.75 0 0 1 .75-.75Z",
+    clipRule: "evenodd"
+  }));
+};
+var ForwardRef = /*#__PURE__*/forwardRef(SignLightLine);
+var Memo = /*#__PURE__*/memo(ForwardRef);
+export default Memo;

package/dist/Icon/index.d.ts

@@ -38,6 +38,7 @@ export { default as LoadingDuotone } from './components/LoadingDuotone';
 export { default as LoadingLine } from './components/LoadingLine';
 export { default as MoreVerticalLine } from './components/MoreVerticalLine';
 export { default as SearchLine } from './components/SearchLine';
+export { default as SignLightLine } from './components/SignLightLine';
 export { default as SortAscendingOrderColor } from './components/SortAscendingOrderColor';
 export { default as SortColor } from './components/SortColor';
 export { default as SortDescendingOrderColor } from './components/SortDescendingOrderColor';

package/dist/Icon/index.js

@@ -38,6 +38,7 @@ export { default as LoadingDuotone } from "./components/LoadingDuotone";
 export { default as LoadingLine } from "./components/LoadingLine";
 export { default as MoreVerticalLine } from "./components/MoreVerticalLine";
 export { default as SearchLine } from "./components/SearchLine";
+export { default as SignLightLine } from "./components/SignLightLine";
 export { default as SortAscendingOrderColor } from "./components/SortAscendingOrderColor";
 export { default as SortColor } from "./components/SortColor";
 export { default as SortDescendingOrderColor } from "./components/SortDescendingOrderColor";

package/dist/Icon/svg/Sign-light-line.svg

@@ -0,0 +1,3 @@
+<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M12 5.25C12.4142 5.25 12.75 5.58579 12.75 6V11.25H18C18.4142 11.25 18.75 11.5858 18.75 12C18.75 12.4142 18.4142 12.75 18 12.75H12.75V18C12.75 18.4142 12.4142 18.75 12 18.75C11.5858 18.75 11.25 18.4142 11.25 18V12.75H6C5.58579 12.75 5.25 12.4142 5.25 12C5.25 11.5858 5.58579 11.25 6 11.25H11.25V6C11.25 5.58579 11.5858 5.25 12 5.25Z" fill="black"/>
+</svg>

package/dist/List/index.js

@@ -12,7 +12,6 @@ function List(props) {
   var _props$dataSource = props.dataSource,
     dataSource = _props$dataSource === void 0 ? [] : _props$dataSource,
     renderItem = props.renderItem,
-    bordered = props.bordered,
     customizeSize = props.size,
     rowKey = props.rowKey,
     children = props.children,
@@ -60,9 +59,7 @@ function List(props) {
     return key;
   }
   var size = customizeSize || 'default';
-  var customizeClassNames = classNames('ald-list', _defineProperty({
-    'ald-list-bordered': bordered
-  }, "ald-list-".concat(size), size), className);
+  var customizeClassNames = classNames('ald-list', _defineProperty({}, "ald-list-".concat(size), size), className);
   if (virtual) {
     var renderInnerItem = function renderInnerItem(index) {
       if (!renderItem) return null;

package/dist/LogicTree/DisplayLogicTree.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { TNode } from './type';
+interface IProps<T> {
+    value?: TNode<T>;
+    renderCondition: (data: T) => React.ReactNode;
+    backgroundColor?: string;
+}
+export default function DisplayLogicTree<T>({ value, renderCondition, backgroundColor, }: IProps<T>): React.JSX.Element | null;
+export {};

package/dist/LogicTree/DisplayLogicTree.js

@@ -0,0 +1,14 @@
+import React from 'react';
+import { DisplayLogicItem } from "./components/DisplayLogicItem";
+export default function DisplayLogicTree(_ref) {
+  var value = _ref.value,
+    renderCondition = _ref.renderCondition,
+    backgroundColor = _ref.backgroundColor;
+  if (!value) return null;
+  return /*#__PURE__*/React.createElement(DisplayLogicItem, {
+    key: value.id,
+    value: value,
+    renderCondition: renderCondition,
+    backgroundColor: backgroundColor
+  });
+}

package/dist/LogicTree/components/DisplayLogicItem/index.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { TNode } from '../../type';
+interface IProps<T> {
+    value: TNode<T>;
+    renderCondition: (value: T) => React.ReactNode;
+    backgroundColor?: string;
+    key: string;
+}
+export declare function DisplayLogicItem<T>({ value, renderCondition, backgroundColor, key, }: IProps<T>): React.JSX.Element | null;
+export {};

package/dist/LogicTree/components/DisplayLogicItem/index.js

@@ -0,0 +1,87 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import _ from 'lodash';
+import React, { useContext, useState } from 'react';
+import { LocaleContext, getTranslator } from "../../../locale/default";
+import { ELogicType, ENodeType } from "../../type";
+var TWO = 2;
+export function DisplayLogicItem(_ref) {
+  var _logicTypeTextMap;
+  var value = _ref.value,
+    renderCondition = _ref.renderCondition,
+    backgroundColor = _ref.backgroundColor,
+    key = _ref.key;
+  var _useState = useState(0),
+    _useState2 = _slicedToArray(_useState, 2),
+    firstNodeHight = _useState2[0],
+    setFirstNodeHight = _useState2[1];
+  var _useState3 = useState(0),
+    _useState4 = _slicedToArray(_useState3, 2),
+    lastNodeHight = _useState4[0],
+    setLastNodeHight = _useState4[1];
+  var _useContext = useContext(LocaleContext),
+    locale = _useContext.locale;
+  var t = getTranslator(locale);
+  var logicTypeTextMap = (_logicTypeTextMap = {}, _defineProperty(_logicTypeTextMap, ELogicType.AND, t.LogicTree.select.and), _defineProperty(_logicTypeTextMap, ELogicType.OR, t.LogicTree.select.or), _logicTypeTextMap);
+  var type = value.type;
+  var firstRefCallback = function firstRefCallback(e) {
+    if (e) {
+      setFirstNodeHight(e.clientHeight);
+    }
+  };
+  var lastRefCallback = function lastRefCallback(e) {
+    if (e) {
+      setLastNodeHight(e.clientHeight);
+    }
+  };
+  if (type === ENodeType.LOGIC) {
+    var nodes = value.nodes;
+    if (!_.size(nodes)) return null;
+    return /*#__PURE__*/React.createElement("div", {
+      className: "ald-logic-tree-display-logic-node"
+    }, _.map(nodes, function (node, index) {
+      var ref = null;
+      if (index === 0) {
+        ref = firstRefCallback;
+      } else if (index === nodes.length - 1) {
+        ref = lastRefCallback;
+      }
+      return /*#__PURE__*/React.createElement("div", {
+        className: "ald-logic-tree-node-wrap",
+        ref: ref,
+        key: key
+      }, /*#__PURE__*/React.createElement("div", {
+        className: "ald-logic-tree-horizontal-line"
+      }), /*#__PURE__*/React.createElement(DisplayLogicItem, {
+        key: node.id,
+        value: node,
+        renderCondition: renderCondition,
+        backgroundColor: backgroundColor
+      }));
+    }), /*#__PURE__*/React.createElement("div", {
+      className: "ald-logic-tree-logic-type",
+      style: {
+        backgroundColor: backgroundColor
+      }
+    }, logicTypeTextMap[value.logicType]), nodes.length > 1 && /*#__PURE__*/React.createElement("div", {
+      className: "ald-logic-tree-logic-vertical-line",
+      style: {
+        height: "calc(100% - ".concat(firstNodeHight / TWO, "px - ").concat(lastNodeHight / TWO, "px"),
+        top: "".concat(firstNodeHight / TWO, "px")
+      }
+    }));
+  }
+  return /*#__PURE__*/React.createElement("div", {
+    className: "ald-logic-tree-display-record-node"
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "ald-logic-tree-render-condition-wrap"
+  }, renderCondition(value.data)));
+}

package/dist/LogicTree/components/LogicItem/index.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { TRenderCondition } from '../..';
+import { ELogicType, TNode } from '../../type';
+interface IProps<T> {
+    value: TNode<T>;
+    addCondition: (id: string) => void;
+    addRelation: (id: string) => void;
+    remove: (id: string) => void;
+    changeRecordData: (id: string, data: T) => void;
+    changeRelation: (id: string, logicType: ELogicType) => void;
+    renderCondition: TRenderCondition<T>;
+}
+export default function LogicItem<T>({ value, addCondition, addRelation, changeRecordData, remove, changeRelation, renderCondition, }: IProps<T>): React.JSX.Element;
+export {};

package/dist/LogicTree/components/LogicItem/index.js

@@ -0,0 +1,144 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import _ from 'lodash';
+import React, { useContext, useState } from 'react';
+import PlusIcon from "../../../Icon/components/SignLightLine";
+import CloseIcon from "../../../Icon/components/TimesLightLine";
+import IconButton from "../../../IconButton";
+import Select from "../../../Select";
+import TextLink from "../../../TextLink";
+import { LocaleContext, getTranslator } from "../../../locale/default";
+import { ELogicType, ENodeType } from "../../type";
+var TWO = 2;
+export default function LogicItem(_ref) {
+  var value = _ref.value,
+    addCondition = _ref.addCondition,
+    addRelation = _ref.addRelation,
+    changeRecordData = _ref.changeRecordData,
+    remove = _ref.remove,
+    changeRelation = _ref.changeRelation,
+    renderCondition = _ref.renderCondition;
+  var _useState = useState(0),
+    _useState2 = _slicedToArray(_useState, 2),
+    firstNodeHight = _useState2[0],
+    setFirstNodeHight = _useState2[1];
+  var _useState3 = useState(0),
+    _useState4 = _slicedToArray(_useState3, 2),
+    lastNodeHight = _useState4[0],
+    setLastNodeHight = _useState4[1];
+  var _useContext = useContext(LocaleContext),
+    locale = _useContext.locale;
+  var t = getTranslator(locale);
+  var logicOptions = [{
+    value: ELogicType.AND,
+    label: t.LogicTree.select.and
+  }, {
+    value: ELogicType.OR,
+    label: t.LogicTree.select.or
+  }];
+  var type = value.type;
+  var firstRefCallback = function firstRefCallback(e) {
+    if (e) {
+      setFirstNodeHight(e.clientHeight);
+    }
+  };
+  var lastRefCallback = function lastRefCallback(e) {
+    if (e) {
+      setLastNodeHight(e.clientHeight);
+    }
+  };
+  var onAddCondition = function onAddCondition() {
+    var id = value.id;
+    addCondition(id);
+  };
+  var onAddRelation = function onAddRelation() {
+    var id = value.id;
+    addRelation(id);
+  };
+  var onRemove = function onRemove() {
+    var id = value.id;
+    remove(id);
+  };
+  var onChangeRelation = function onChangeRelation(logicType) {
+    var id = value.id;
+    changeRelation(id, logicType);
+  };
+  var onChangeRecordData = function onChangeRecordData(data) {
+    var id = value.id;
+    changeRecordData(id, data);
+  };
+  if (type === ENodeType.LOGIC) {
+    var nodes = value.nodes,
+      _logicType = value.logicType;
+    var verticalLineHeight = nodes.length > 1 ? "calc(100% - ".concat(firstNodeHight / TWO, "px - ").concat(lastNodeHight / TWO, "px - 40px)") : "30px";
+    return /*#__PURE__*/React.createElement("div", {
+      className: "ald-logic-tree-logic-node"
+    }, _.map(nodes, function (node, index) {
+      var ref = null;
+      if (index === 0) {
+        ref = firstRefCallback;
+      } else if (index === nodes.length - 1) {
+        ref = lastRefCallback;
+      }
+      return /*#__PURE__*/React.createElement("div", {
+        className: "ald-logic-tree-node-wrap",
+        ref: ref,
+        key: node.id
+      }, /*#__PURE__*/React.createElement("div", {
+        className: "ald-logic-tree-horizontal-line"
+      }), /*#__PURE__*/React.createElement(LogicItem, {
+        key: node.id,
+        value: node,
+        addCondition: addCondition,
+        addRelation: addRelation,
+        remove: remove,
+        changeRelation: changeRelation,
+        renderCondition: renderCondition,
+        changeRecordData: changeRecordData
+      }));
+    }), /*#__PURE__*/React.createElement("div", {
+      className: "ald-logic-tree-operation"
+    }, /*#__PURE__*/React.createElement("div", {
+      className: "ald-logic-tree-left-bottom-dash-line"
+    }), /*#__PURE__*/React.createElement(TextLink, {
+      icon: /*#__PURE__*/React.createElement(PlusIcon, {
+        size: 24
+      }),
+      onClick: onAddCondition
+    }, t.LogicTree.btn.addCondition), /*#__PURE__*/React.createElement(TextLink, {
+      icon: /*#__PURE__*/React.createElement(PlusIcon, {
+        size: 24
+      }),
+      onClick: onAddRelation
+    }, t.LogicTree.btn.addRelation)), !!_.size(nodes) && /*#__PURE__*/React.createElement("div", {
+      className: "ald-logic-tree-logic-vertical-line",
+      style: {
+        height: verticalLineHeight,
+        top: "".concat(firstNodeHight / TWO, "px")
+      }
+    }), /*#__PURE__*/React.createElement(Select, {
+      options: logicOptions,
+      className: "ald-logic-tree-select-relation",
+      size: "small",
+      value: _logicType,
+      onChange: onChangeRelation,
+      disabled: nodes.length <= 1
+    }));
+  }
+  return /*#__PURE__*/React.createElement("div", {
+    className: "ald-logic-tree-record-node"
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "ald-logic-tree-render-condition-wrap"
+  }, renderCondition(value.data, {
+    changeData: onChangeRecordData
+  })), /*#__PURE__*/React.createElement(IconButton, {
+    icon: /*#__PURE__*/React.createElement(CloseIcon, {
+      size: 24
+    }),
+    onClick: onRemove
+  }));
+}

package/dist/LogicTree/helper.d.ts

@@ -0,0 +1,8 @@
+import { ELogicType, TNode } from './type';
+export declare function addLogicNode<T>(nodeId: string, rootNode: TNode<T>, newInitializationData: T): TNode<T>;
+export declare function addRecordNode<T>(nodeId: string, rootNode: TNode<T>, newInitializationData: T): TNode<T>;
+export declare function removeNode<T>(nodeId: string, rootNode: TNode<T>, initialNode: TNode<T>, rootNodeAllowedEmpty?: boolean): TNode<T>;
+export declare function changeRelation<T>(id: string, logicType: ELogicType, rootNode: TNode<T>): TNode<T>;
+export declare function changeRecordData<T>(id: string, newData: T, rootNode: TNode<T>): TNode<T>;
+export declare function getInitialLogicNode<T>(initialData: T[]): TNode<T>;
+export declare function logicTreeIterator<T, U>(rootNode: TNode<T>, callback: (node: TNode<T>, acc: U[]) => U): U;

package/dist/LogicTree/helper.js

@@ -0,0 +1,183 @@
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+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; }
+import _ from 'lodash';
+import { getUniqId } from "../_utils/getUniqId";
+import { ELogicType, ENodeType } from "./type";
+
+// 递归查找节点
+function findNodeById(nodeId, currentNodes) {
+  if (nodeId === currentNodes.id) {
+    return currentNodes;
+  }
+  if (currentNodes.type === ENodeType.LOGIC) {
+    var childrenNodes = currentNodes.nodes;
+    var _iterator = _createForOfIteratorHelper(childrenNodes),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var _node = _step.value;
+        var foundNode = findNodeById(nodeId, _node);
+        if (foundNode) {
+          return foundNode;
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  }
+  return undefined;
+}
+
+// 递归查找父节点
+function findParentNodeById(nodeId, currentNodes) {
+  if (currentNodes.type === ENodeType.LOGIC) {
+    var childrenNodes = currentNodes.nodes;
+    var _iterator2 = _createForOfIteratorHelper(childrenNodes),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var _node2 = _step2.value;
+        if (_node2.id === nodeId) {
+          return currentNodes;
+        }
+        var foundNode = findParentNodeById(nodeId, _node2);
+        if (foundNode) {
+          return foundNode;
+        }
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+  }
+  return undefined;
+}
+
+// 添加logic节点
+export function addLogicNode(nodeId, rootNode, newInitializationData) {
+  var newRootNode = _.cloneDeep(rootNode);
+  var newNode = {
+    id: getUniqId(),
+    type: ENodeType.LOGIC,
+    logicType: ELogicType.AND,
+    nodes: [{
+      id: getUniqId(),
+      // 生成唯一 id
+      type: ENodeType.RECORD,
+      data: newInitializationData
+    }]
+  };
+  var parent = findNodeById(nodeId, newRootNode);
+  if (parent && parent.type === ENodeType.LOGIC) {
+    parent.nodes.push(newNode);
+    return newRootNode;
+  }
+  return rootNode;
+}
+
+// 添加record节点
+export function addRecordNode(nodeId, rootNode, newInitializationData) {
+  var newRootNode = _.cloneDeep(rootNode);
+  var newNode = {
+    id: getUniqId(),
+    // 生成唯一 id
+    type: ENodeType.RECORD,
+    data: newInitializationData
+  };
+  var parent = findNodeById(nodeId, newRootNode);
+  if (parent && parent.type === ENodeType.LOGIC) {
+    parent.nodes.push(newNode);
+    return newRootNode;
+  }
+  return rootNode;
+}
+
+// 移除节点
+export function removeNode(nodeId, rootNode, initialNode, rootNodeAllowedEmpty) {
+  var newRootNode = _.cloneDeep(rootNode);
+  var parent = findParentNodeById(nodeId, newRootNode);
+  if (parent) {
+    if (parent.nodes.length === 1) {
+      if (rootNodeAllowedEmpty && parent.id === rootNode.id) {
+        parent.nodes = [];
+        return newRootNode;
+      } else {
+        if (parent.id === rootNode.id) {
+          return initialNode;
+        }
+      }
+      var removeNodeId = nodeId;
+      do {
+        removeNodeId = parent.id;
+        parent = findParentNodeById(parent.id, newRootNode);
+      } while (parent && parent.id !== rootNode.id && parent.nodes.length === 1);
+      if (parent) {
+        parent.nodes.splice(parent.nodes.findIndex(function (node) {
+          return node.id === removeNodeId;
+        }), 1);
+      }
+      return newRootNode;
+    } else {
+      parent.nodes.splice(parent.nodes.findIndex(function (node) {
+        return node.id === nodeId;
+      }), 1);
+      return newRootNode;
+    }
+  }
+  return rootNode;
+}
+
+// 修改logic节点关系
+export function changeRelation(id, logicType, rootNode) {
+  var newRootNode = _.cloneDeep(rootNode);
+  var node = findNodeById(id, newRootNode);
+  if (node && node.type === ENodeType.LOGIC) {
+    node.logicType = logicType;
+    return newRootNode;
+  }
+  return rootNode;
+}
+
+// 修改record节点数据
+export function changeRecordData(id, newData, rootNode) {
+  var newRootNode = _.cloneDeep(rootNode);
+  var node = findNodeById(id, newRootNode);
+  if (node && node.type === ENodeType.RECORD) {
+    node.data = newData;
+    return newRootNode;
+  }
+  return rootNode;
+}
+export function getInitialLogicNode(initialData) {
+  return {
+    id: getUniqId(),
+    type: ENodeType.LOGIC,
+    logicType: ELogicType.AND,
+    nodes: initialData.map(function (item) {
+      return {
+        id: getUniqId(),
+        type: ENodeType.RECORD,
+        data: item
+      };
+    })
+  };
+}
+
+// 深度优先遍历
+export function logicTreeIterator(rootNode, callback) {
+  if (rootNode.type === ENodeType.LOGIC) {
+    var nodes = rootNode.nodes;
+    var result = nodes.map(function (childNode) {
+      return logicTreeIterator(childNode, callback);
+    });
+    return callback(rootNode, result);
+  }
+  if (rootNode.type === ENodeType.RECORD) {
+    return callback(rootNode, []);
+  }
+  return callback(rootNode, []);
+}

package/dist/LogicTree/index.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import DisplayLogicTree from './DisplayLogicTree';
+import { ELogicType, ENodeType, TNode } from './type';
+export type { TNode };
+export { DisplayLogicTree, ELogicType, ENodeType };
+export type TRenderCondition<T> = (data: T, { changeData }: {
+    changeData: (data: T) => void;
+}) => React.ReactNode;
+interface IProps<T> {
+    newInitializationData: T;
+    onChange: (value: TNode<T>) => void;
+    value?: TNode<T>;
+    renderCondition: TRenderCondition<T>;
+    rootNodeAllowedEmpty?: boolean;
+    className?: string;
+}
+export default function LogicTree<T>(props: IProps<T>): React.JSX.Element | null;