ebaoferc 2.0.8 → 2.0.9-beta.0

package/dist/components/MindGraph/core/graphic/drag.js

@@ -28,13 +28,13 @@ export var Drag = /*#__PURE__*/_createClass(function Drag(context) {
   _defineProperty(this, "temporaryLine", void 0);
   _defineProperty(this, "container", void 0);
   _defineProperty(this, "draggableLayout", void 0);
-  /**
-   * 获取拖动节点插入到关联节点子代的下标
-   * @param attachedNodeChildren 关联节点的子代
-   * @param dropPosition 拖动节点镜像中心位置
-   * @param dragNode 拖动节点
-   * @param attachedNode 被关联的节点
-   * @return 期望插入位置
+  /**
+   * 获取拖动节点插入到关联节点子代的下标
+   * @param attachedNodeChildren 关联节点的子代
+   * @param dropPosition 拖动节点镜像中心位置
+   * @param dragNode 拖动节点
+   * @param attachedNode 被关联的节点
+   * @return 期望插入位置
    */
   _defineProperty(this, "calcDropIndex", function (attachedNodeChildren, dropPosition, dragNode, attachedNode) {
     return _this.draggableLayout.calcDropIndex({
@@ -47,12 +47,12 @@ export var Drag = /*#__PURE__*/_createClass(function Drag(context) {
       root: _this.root
     });
   });
-  /**
-   * 拖动操作
-   * - 根节点不可拖拽
-   * @param position 拖动节点镜像中心位置
-   * @param canBeAttachedNodes 需要搜索的可关联节点
-   * @return 链接关联信息
+  /**
+   * 拖动操作
+   * - 根节点不可拖拽
+   * @param position 拖动节点镜像中心位置
+   * @param canBeAttachedNodes 需要搜索的可关联节点
+   * @return 链接关联信息
    */
   _defineProperty(this, "drag", function (position, canBeAttachedNodes) {
     var cache = _this.cacheMap.get(_this.dragNode.id);
@@ -88,8 +88,8 @@ export var Drag = /*#__PURE__*/_createClass(function Drag(context) {
       return undefined;
     }
   });
-  /**
-   * 通知控制器拖动操作结束
+  /**
+   * 通知控制器拖动操作结束
    */
   _defineProperty(this, "end", function () {
     _this.temporaryLine.destroy();

package/dist/components/MindGraph/core/graphic/index.js

@@ -14,20 +14,20 @@ import { Drag } from "./drag";
 import { nodeTranslateTo } from "./node-translate-to";
 import { Zoom } from "./zoom";
 export var Graphic = /*#__PURE__*/_createClass(
-/**
- * 脑图管理器
- * - `viewport`用作判断可视区域
- * - svg连线将会自动注入到`container`中
- * - transform 相关信息将会自动注入到`container`中
- * @param viewport 视窗
- * @param container 容器
- * @param options 配置参数
+/**
+ * 脑图管理器
+ * - `viewport`用作判断可视区域
+ * - svg连线将会自动注入到`container`中
+ * - transform 相关信息将会自动注入到`container`中
+ * @param viewport 视窗
+ * @param container 容器
+ * @param options 配置参数
  */
 function Graphic(viewport, _container, _options) {
   var _this = this;
   _classCallCheck(this, Graphic);
-  /**
-   * 节点相关信息缓存，树形结构拍平
+  /**
+   * 节点相关信息缓存，树形结构拍平
    */
   _defineProperty(this, "cacheMap", new Map());
   _defineProperty(this, "options", void 0);
@@ -39,16 +39,16 @@ function Graphic(viewport, _container, _options) {
   _defineProperty(this, "resizeObserver", void 0);
   _defineProperty(this, "unbindCache", []);
   _defineProperty(this, "zoom", void 0);
-  /**
-   * 同步 options 中的 zoom extent
+  /**
+   * 同步 options 中的 zoom extent
    */
   _defineProperty(this, "syncZoomExtentOptions", function () {
     _this.zoom.syncZoomExtentOptions({
       options: _this.options
     });
   });
-  /**
-   * 获取当前可见的节点
+  /**
+   * 获取当前可见的节点
    */
   _defineProperty(this, "getVisibleNodes", function () {
     var nodes = [];
@@ -65,10 +65,10 @@ function Graphic(viewport, _container, _options) {
     }
     return nodes;
   });
-  /**
-   * 获取节点定位锚点（左上角）位置，可在节点绘制的时候确定其位置
-   * - 推荐所有节点使用`position:absolute;left:0;top:0;`并且配合`transform`来定位，避免出现绘制异常
-   * @param id 节点对应id
+  /**
+   * 获取节点定位锚点（左上角）位置，可在节点绘制的时候确定其位置
+   * - 推荐所有节点使用`position:absolute;left:0;top:0;`并且配合`transform`来定位，避免出现绘制异常
+   * @param id 节点对应id
    */
   _defineProperty(this, "getNodeAnchorCoordinate", function (id) {
     var cache = _this.cacheMap.get(id);
@@ -132,9 +132,9 @@ function Graphic(viewport, _container, _options) {
     // 回调事件，通知外部 transform 改变
     _this.options.callback.onTransformChange(transform);
   });
-  /**
-   * - 计算节点可见是否改变，如改变，则通知外部
-   * - 重渲染连线，销毁不必要的连线
+  /**
+   * - 计算节点可见是否改变，如改变，则通知外部
+   * - 重渲染连线，销毁不必要的连线
    */
   _defineProperty(this, "refreshVisible", function () {
     if (_this.cacheMap.size) {
@@ -150,9 +150,9 @@ function Graphic(viewport, _container, _options) {
     }
   });
   _defineProperty(this, "throttleRefreshVisible", throttle(this.refreshVisible, 100));
-  /**
-   * 视窗尺寸变化
-   * @private
+  /**
+   * 视窗尺寸变化
+   * @private
    */
   _defineProperty(this, "onViewportResize", function () {
     _this.zoom.syncZoomExtent({
@@ -162,9 +162,9 @@ function Graphic(viewport, _container, _options) {
     // 避免频繁的刷新可视区域导致界面卡顿
     _this.throttleRefreshVisible();
   });
-  /**
-   * 注销事件绑定
-   * - 请在销毁组件之前调用
+  /**
+   * 注销事件绑定
+   * - 请在销毁组件之前调用
    */
   _defineProperty(this, "unbind", function () {
     _this.unbindCache.forEach(function (dispose) {
@@ -172,9 +172,9 @@ function Graphic(viewport, _container, _options) {
     });
     _this.unbindCache = [];
   });
-  /**
-   * 判断节点是否可视
-   * @param id 节点对应id
+  /**
+   * 判断节点是否可视
+   * @param id 节点对应id
    */
   _defineProperty(this, "judgeNodeVisible", function (id) {
     var cache = _this.cacheMap.get(id);
@@ -184,11 +184,11 @@ function Graphic(viewport, _container, _options) {
       return false;
     }
   });
-  /**
-   * 设定 `options`
-   * - 函数不会自动执行重渲染，如果改变的`options`需要重新计算布局等操作，推荐使用 `setData` 驱动数据重渲染
-   * @param options 设定选项
-   * @param isMerge 是否与之前的`options`做合并操作
+  /**
+   * 设定 `options`
+   * - 函数不会自动执行重渲染，如果改变的`options`需要重新计算布局等操作，推荐使用 `setData` 驱动数据重渲染
+   * @param options 设定选项
+   * @param isMerge 是否与之前的`options`做合并操作
    */
   _defineProperty(this, "setOptions", function (options) {
     var isMerge = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
@@ -199,14 +199,14 @@ function Graphic(viewport, _container, _options) {
     }
     _this.syncZoomExtentOptions();
   });
-  /**
-   * 生成拖动控制器
-   * - 根节点不可拖拽
-   * - 当前暂时只有`Mind.ChildAlignMode.structured`布局算法支持拖拽功能
-   * @param drag 拖动节点node对象或id
-   * @return
-   * - 当root（没有调用`setData`）不存在时，或者`drag`为根节点时，返回`undefined`
-   * - 正常情况返回 `Drag` 类对象
+  /**
+   * 生成拖动控制器
+   * - 根节点不可拖拽
+   * - 当前暂时只有`Mind.ChildAlignMode.structured`布局算法支持拖拽功能
+   * @param drag 拖动节点node对象或id
+   * @return
+   * - 当root（没有调用`setData`）不存在时，或者`drag`为根节点时，返回`undefined`
+   * - 正常情况返回 `Drag` 类对象
    */
   _defineProperty(this, "dragControllerBuilder", function (drag) {
     var _this$cacheMap$get;
@@ -223,8 +223,8 @@ function Graphic(viewport, _container, _options) {
       return undefined;
     }
   });
-  /**
-   * 获取渲染层尺寸
+  /**
+   * 获取渲染层尺寸
    */
   _defineProperty(this, "getLayoutSize", function () {
     var _this$root;
@@ -235,70 +235,70 @@ function Graphic(viewport, _container, _options) {
       return undefined;
     }
   });
-  /**
-   * 获取`id`对应节点
-   * @param id 节点`id`
+  /**
+   * 获取`id`对应节点
+   * @param id 节点`id`
    */
   _defineProperty(this, "getNode", function (id) {
     var _this$cacheMap$get2;
     return (_this$cacheMap$get2 = _this.cacheMap.get(id)) === null || _this$cacheMap$get2 === void 0 ? void 0 : _this$cacheMap$get2.node;
   });
-  /**
-   * 获取`id`对应节点父级
-   * @param id 节点`id`
+  /**
+   * 获取`id`对应节点父级
+   * @param id 节点`id`
    */
   _defineProperty(this, "getParent", function (id) {
     var _this$cacheMap$get3;
     return (_this$cacheMap$get3 = _this.cacheMap.get(id)) === null || _this$cacheMap$get3 === void 0 ? void 0 : _this$cacheMap$get3.parent;
   });
-  /**
-   * 获取`id`对应节点渲染方位
-   * @param id 节点`id`
+  /**
+   * 获取`id`对应节点渲染方位
+   * @param id 节点`id`
    */
   _defineProperty(this, "getNodeOrientation", function (id) {
     var _this$cacheMap$get4;
     return (_this$cacheMap$get4 = _this.cacheMap.get(id)) === null || _this$cacheMap$get4 === void 0 ? void 0 : _this$cacheMap$get4.orientation;
   });
-  /**
-   * 主动设置位移缩放
-   * - 会与之前的`transform`做深度合并
-   * - 请注意：`setTransform` 之后 `onTransformChange` 事件依旧会触发
-   * - 此方法不受 `zoomExtent.translate`、`zoomExtent.scale` 限制
-   * @param transform 位移缩放数据
-   * @param duration 周期，如果配置，则执行变换会附带动画效果
+  /**
+   * 主动设置位移缩放
+   * - 会与之前的`transform`做深度合并
+   * - 请注意：`setTransform` 之后 `onTransformChange` 事件依旧会触发
+   * - 此方法不受 `zoomExtent.translate`、`zoomExtent.scale` 限制
+   * @param transform 位移缩放数据
+   * @param duration 周期，如果配置，则执行变换会附带动画效果
    */
   _defineProperty(this, "setTransform", function (transform, duration) {
     _this.transform = merge({}, _this.transform, transform);
     _this.zoom.setTransform(_this.transform, duration);
   });
-  /**
-   * 设定位移
-   * - 此方法受到 `zoomExtent.translate` 限制
-   * @param translate 位移差(屏幕尺度)
-   * @param duration 周期，如果配置，则执行变换会附带动画效果
+  /**
+   * 设定位移
+   * - 此方法受到 `zoomExtent.translate` 限制
+   * @param translate 位移差(屏幕尺度)
+   * @param duration 周期，如果配置，则执行变换会附带动画效果
    */
   _defineProperty(this, "translate", function (translate, duration) {
     _this.zoom.translate(translate, duration);
   });
-  /**
-   * 设定缩放
-   * - 此方法受到 `zoomExtent.translate` 限制
-   * - 此方法受到 `zoomExtent.scale` 限制
-   * @param scale 缩放比
-   * @param point 缩放相对点（如不配置或为`undefined`，则默认相对于`viewport`中心缩放）
-   * @param duration 动画周期，如配置，则位移会附带动画效果
+  /**
+   * 设定缩放
+   * - 此方法受到 `zoomExtent.translate` 限制
+   * - 此方法受到 `zoomExtent.scale` 限制
+   * @param scale 缩放比
+   * @param point 缩放相对点（如不配置或为`undefined`，则默认相对于`viewport`中心缩放）
+   * @param duration 动画周期，如配置，则位移会附带动画效果
    */
   _defineProperty(this, "scale", function (scale, point, duration) {
     _this.zoom.scale(scale, point, duration);
   });
-  /**
-   * 将某一个节点中心从某个相对位置做位移（其尺度为屏幕尺度）操作
-   * - 此方法不受 `zoomExtent.translate` 限制
-   * @param config 配置参数
-   * @param config.id 节点id
-   * @param config.diff 位移差
-   * @param config.relative 相对位置
-   * @param duration 动画周期，如配置，则位移会附带动画效果
+  /**
+   * 将某一个节点中心从某个相对位置做位移（其尺度为屏幕尺度）操作
+   * - 此方法不受 `zoomExtent.translate` 限制
+   * @param config 配置参数
+   * @param config.id 节点id
+   * @param config.diff 位移差
+   * @param config.relative 相对位置
+   * @param duration 动画周期，如配置，则位移会附带动画效果
    */
   _defineProperty(this, "nodeTranslateTo", function (config, duration) {
     var id = config.id,
@@ -314,24 +314,24 @@ function Graphic(viewport, _container, _options) {
       zoom: _this.zoom
     }, duration);
   });
-  /**
-   * 获取位移缩放信息
+  /**
+   * 获取位移缩放信息
    */
   _defineProperty(this, "getTransform", function () {
     return _objectSpread({}, _this.transform);
   });
-  /**
-   * 设置锚点节点
-   * @param id 锚定节点id(如不设定，则清空锚点，根节点居中，缩放比归一)
+  /**
+   * 设置锚点节点
+   * @param id 锚定节点id(如不设定，则清空锚点，根节点居中，缩放比归一)
    */
   _defineProperty(this, "setAnchor", function (id) {
     _this.anchor = id;
   });
-  /**
-   * 设置/更新数据，启动重渲染
-   * - 在重计算定位时，将保持 `anchor` 对应节点在屏幕上的相对位置不变
-   * - 如果 `anchor` 没有设定，或者找不到对应节点，则，根节点居中，缩放比重置为1
-   * @param root 根数据
+  /**
+   * 设置/更新数据，启动重渲染
+   * - 在重计算定位时，将保持 `anchor` 对应节点在屏幕上的相对位置不变
+   * - 如果 `anchor` 没有设定，或者找不到对应节点，则，根节点居中，缩放比重置为1
+   * @param root 根数据
    */
   _defineProperty(this, "setData", function (root) {
     _this.root = root;
@@ -346,17 +346,17 @@ function Graphic(viewport, _container, _options) {
     // 设定数据后，通知外部可见节点
     _this.options.callback.onNodeVisibleChange(_this.getVisibleNodes());
   });
-  /**
-   * 刷新
+  /**
+   * 刷新
    */
   _defineProperty(this, "refresh", function () {
     if (_this.root) {
       _this.setData(_this.root);
     }
   });
-  /**
-   * 渲染链接到某个`container`下
-   * @param container 容器
+  /**
+   * 渲染链接到某个`container`下
+   * @param container 容器
    */
   _defineProperty(this, "connectTo", function (container) {
     Render.connect({
@@ -366,8 +366,8 @@ function Graphic(viewport, _container, _options) {
       root: _this.root
     });
   });
-  /**
-   * 同步渲染层尺寸到 container 中
+  /**
+   * 同步渲染层尺寸到 container 中
    */
   _defineProperty(this, "syncLayoutSize", function () {
     var _this$cacheMap$get5, _this$root2;
@@ -378,15 +378,15 @@ function Graphic(viewport, _container, _options) {
     _this.container.style.width = "".concat(layoutSize.width, "px");
     _this.container.style.height = "".concat(layoutSize.height, "px");
   });
-  /**
-   * 链接各个节点
+  /**
+   * 链接各个节点
    */
   _defineProperty(this, "connect", function () {
     _this.connectTo(_this.container);
   });
-  /**
-   * 计算脑图布局
-   * - 请保证调用之前 data 已经通过 setData 设置完备
+  /**
+   * 计算脑图布局
+   * - 请保证调用之前 data 已经通过 setData 设置完备
    */
   _defineProperty(this, "layout", function () {
     Render.layout({
@@ -400,8 +400,8 @@ function Graphic(viewport, _container, _options) {
       zoom: _this.zoom
     });
   });
-  /**
-   * 计算各节点可见性，以及链接可见性
+  /**
+   * 计算各节点可见性，以及链接可见性
    */
   _defineProperty(this, "calcVisible", function () {
     return Render.calcVisible({

package/dist/components/MindGraph/core/helper/depth-first-walk-tree.js

@@ -1,7 +1,7 @@
-/**
- * 深度优先遍历
- * @param root 根节点
- * @param callback before:递归之前(返回 true 代表继续搜索子代，false代表终止),after:子代递归完成返回
+/**
+ * 深度优先遍历
+ * @param root 根节点
+ * @param callback before:递归之前(返回 true 代表继续搜索子代，false代表终止),after:子代递归完成返回
  */
 export var depthFirstWalkTree = function depthFirstWalkTree(root, callback) {
   var recursion = function recursion(now, parent) {

package/dist/components/MindGraph/core/helper/descendant.js

@@ -1,9 +1,9 @@
 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; }
-/**
- * 获取某个节点的所有后代
- * @param node 节点
+/**
+ * 获取某个节点的所有后代
+ * @param node 节点
  */
 export var descendant = function descendant(node) {
   var result = [];

package/dist/components/MindGraph/core/helper/get-layout-calc-children.js

@@ -1,12 +1,12 @@
 import { Mind } from "../index";
 import { Helper } from "./index";
 
-/**
- * 获取用于布局计算的子代
- * - 剔除掉被折叠的部分
- * @param node
- * @param rootId
- * @param getRootHeirOrientation
+/**
+ * 获取用于布局计算的子代
+ * - 剔除掉被折叠的部分
+ * @param node
+ * @param rootId
+ * @param getRootHeirOrientation
  */
 export var getLayoutCalcChildren = function getLayoutCalcChildren(node, rootId, getRootHeirOrientation) {
   // 判断是否所有子代都折叠了

package/dist/components/MindGraph/core/helper/index.d.ts

@@ -1,23 +1,23 @@
 export declare const Helper: {
-    breadthFirstWalkTree: (node: import("../../../..").Mind.Node, callback: {
-        before: (node: import("../../../..").Mind.Node) => boolean;
-        after: (rank: import("../../../..").Mind.Node[]) => void;
+    breadthFirstWalkTree: (node: import("..").Mind.Node, callback: {
+        before: (node: import("..").Mind.Node) => boolean;
+        after: (rank: import("..").Mind.Node[]) => void;
     }) => void;
-    depthFirstWalkTree: (root: import("../../../..").Mind.Node, callback: {
-        before: (node: import("../../../..").Mind.Node, parent?: import("../../../..").Mind.Node | undefined) => boolean;
-        after: (node: import("../../../..").Mind.Node, parent?: import("../../../..").Mind.Node | undefined) => void;
+    depthFirstWalkTree: (root: import("..").Mind.Node, callback: {
+        before: (node: import("..").Mind.Node, parent?: import("..").Mind.Node | undefined) => boolean;
+        after: (node: import("..").Mind.Node, parent?: import("..").Mind.Node | undefined) => void;
     }) => void;
-    descendant: (node: import("../../../..").Mind.Node) => import("../../../..").Mind.Node[];
+    descendant: (node: import("..").Mind.Node) => import("..").Mind.Node[];
     error: (message: string) => Error;
-    getLayoutCalcChildren: (node: import("../../../..").Mind.Node, rootId: string, getRootHeirOrientation: import("../process").Process.getRootHeirOrientationFunc) => import("../../../..").Mind.Node[];
+    getLayoutCalcChildren: (node: import("..").Mind.Node, rootId: string, getRootHeirOrientation: import("../process").Process.getRootHeirOrientationFunc) => import("..").Mind.Node[];
     getSvgPathId: (id: string) => string;
-    judgeIfAllChildFold: (node: import("../../../..").Mind.Node, rootId: string) => boolean;
-    judgeIfHeirAndFold: (node: import("../../../..").Mind.Node, parent: import("../../../..").Mind.Node | undefined, root: import("../../../..").Mind.Root, getRootHeirOrientation: import("../process").Process.getRootHeirOrientationFunc) => boolean;
-    judgeIfVisualLeaf: (node: import("../../../..").Mind.Node, children?: import("../../../..").Mind.Node[] | undefined) => boolean | boolean[] | undefined;
-    rootToNodeArray: (root: import("../../../..").Mind.Root, callback: (node: import("../../../..").Mind.Node) => void) => import("../../../..").Mind.Node[];
-    transformRootToWalkable: (root: import("../../../..").Mind.Root) => {
-        getRootHeirOrientation: (id: string) => import("../../../..").Mind.Orientation;
-        shadowNode: import("../../../..").Mind.Node;
+    judgeIfAllChildFold: (node: import("..").Mind.Node, rootId: string) => boolean;
+    judgeIfHeirAndFold: (node: import("..").Mind.Node, parent: import("..").Mind.Node | undefined, root: import("..").Mind.Root, getRootHeirOrientation: import("../process").Process.getRootHeirOrientationFunc) => boolean;
+    judgeIfVisualLeaf: (node: import("..").Mind.Node, children?: import("..").Mind.Node[] | undefined) => boolean | boolean[] | undefined;
+    rootToNodeArray: (root: import("..").Mind.Root, callback: (node: import("..").Mind.Node) => void) => import("..").Mind.Node[];
+    transformRootToWalkable: (root: import("..").Mind.Root) => {
+        getRootHeirOrientation: (id: string) => import("..").Mind.Orientation;
+        shadowNode: import("..").Mind.Node;
     };
     withPrefix: (message: string) => string;
 };

package/dist/components/MindGraph/core/helper/judge-if-all-child-fold.js

@@ -1,7 +1,7 @@
-/**
- * 判断节点是否所有子代都需要被折叠
- * @param node
- * @param rootId
+/**
+ * 判断节点是否所有子代都需要被折叠
+ * @param node
+ * @param rootId
  */
 export var judgeIfAllChildFold = function judgeIfAllChildFold(node, rootId) {
   if (node.id === rootId) {

package/dist/components/MindGraph/core/helper/judge-if-heir-and-fold.js

@@ -1,10 +1,10 @@
 import { Mind } from "../index";
-/**
- * 判断节点是否为root直系子代并且已经被折叠了
- * @param node
- * @param parent
- * @param root
- * @param getRootHeirOrientation
+/**
+ * 判断节点是否为root直系子代并且已经被折叠了
+ * @param node
+ * @param parent
+ * @param root
+ * @param getRootHeirOrientation
  */
 export var judgeIfHeirAndFold = function judgeIfHeirAndFold(node, parent, root, getRootHeirOrientation) {
   // 是否为根节点直系子代

package/dist/components/MindGraph/core/helper/judge-if-visual-leaf.js

@@ -1,6 +1,6 @@
-/**
- * 判断节点是否为视觉上的叶节点
- * - 子代被折叠也算视觉上叶节点
+/**
+ * 判断节点是否为视觉上的叶节点
+ * - 子代被折叠也算视觉上叶节点
  */
 export var judgeIfVisualLeaf = function judgeIfVisualLeaf(node, children) {
   return !children || children.length === 0 || node.fold;

package/dist/components/MindGraph/core/index.d.ts

@@ -361,7 +361,9 @@ export declare namespace Mind {
         breadthFirstWalkTree: (node: Node, callback: {
             before: (node: Node) => boolean;
             after: (rank: Node[]) => void;
-        }) => void;
+        }) => void; /**
+         * 直系子代节点中心对齐
+         */
         depthFirstWalkTree: (root: Node, callback: {
             before: (node: Node, parent?: Node | undefined) => boolean;
             after: (node: Node, parent?: Node | undefined) => void;
@@ -384,7 +386,9 @@ export declare namespace Mind {
     export const _WithDefault: {
         cache: (data?: NodeCache | undefined) => Required<NodeCache>;
         options: (data?: Options | undefined) => Required<Options>;
-        transform: (data?: Transform | undefined) => Required<Transform>;
+        transform: (data?: Transform | undefined) => Required<Transform>; /**
+         * y轴垂直方向渲染
+         */
     };
     export {};
 }