ebaoferc 0.3.2 → 0.3.3

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/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,9 +361,7 @@ 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;
@@ -386,9 +384,7 @@ 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>; /**
-         * y轴垂直方向渲染
-         */
+        transform: (data?: Transform | undefined) => Required<Transform>;
     };
     export {};
 }

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

@@ -8,57 +8,57 @@ import { DraggableLayout as DraggableLayoutClass } from "./process/layout/type";
 export var Mind;
 (function (_Mind) {
   var ChildAlignMode = _Mind.ChildAlignMode = {
-    /**
-     * 子代对齐模式
+    /**
+     * 子代对齐模式
      */
     descendantCenter: 'descendant-center',
-    /**
-     * 直系子代节点中心对齐
+    /**
+     * 直系子代节点中心对齐
      */
     heirCenter: 'heir-center',
-    /**
-     * 结构化规整模式
+    /**
+     * 结构化规整模式
      */
     structured: 'structured'
   };
   var Orientation = _Mind.Orientation = {
-    /**
-     * 处于正向区域
+    /**
+     * 处于正向区域
      */
     negative: 'negative',
-    /**
-     * 处于负向区域
+    /**
+     * 处于负向区域
      */
     positive: 'positive',
-    /**
-     * 根节点
+    /**
+     * 根节点
      */
     root: 'root'
   };
   var Direction = _Mind.Direction = {
-    /**
-     * x轴水平方向渲染
+    /**
+     * x轴水平方向渲染
      */
     x: 'x',
-    /**
-     * y轴垂直方向渲染
+    /**
+     * y轴垂直方向渲染
      */
     y: 'y'
   };
   var LinkStyle = _Mind.LinkStyle = {
-    /**
-     * 贝塞尔曲线
+    /**
+     * 贝塞尔曲线
      */
     bezier: 'bezier',
-    /**
-     * 线性
-     * - 线性只有在 ChildAlignMode.structured 风格下表现最佳
+    /**
+     * 线性
+     * - 线性只有在 ChildAlignMode.structured 风格下表现最佳
      */
     line: 'line'
   };
 
-  /**
-   * 拖动关联信息
+  /**
+   * 拖动关联信息
    */
 
   var RelativeX = _Mind.RelativeX = {
@@ -72,9 +72,9 @@ export var Mind;
     top: 'top'
   };
 
-  /**
-   * 位移/缩放事件函数
-   * @param event the underlying input event, such as mousemove or touchmove
+  /**
+   * 位移/缩放事件函数
+   * @param event the underlying input event, such as mousemove or touchmove
    */
 
   var Graphic = _Mind.Graphic = GraphicClass;

package/dist/components/MindGraph/core/process/layout/structured/get-node-cross-boundary.js

@@ -1,11 +1,11 @@
 import { Helper } from "../../../helper";
-/**
- * 获取节点交叉轴边界
- * - 如果存在视觉子代，请保证视觉子代边界计算完成
- * @param cache
- * @param children
- * @param vertical
- * @param cacheMap
+/**
+ * 获取节点交叉轴边界
+ * - 如果存在视觉子代，请保证视觉子代边界计算完成
+ * @param cache
+ * @param children
+ * @param vertical
+ * @param cacheMap
  */
 export var getNodeCrossBoundary = function getNodeCrossBoundary(cache, children, vertical, cacheMap) {
   var boundary = {

package/dist/components/MindGraph/core/process/layout/type.js

@@ -10,38 +10,38 @@ import { Helper } from "../../helper";
 export var DraggableLayout = /*#__PURE__*/_createClass(function DraggableLayout() {
   _classCallCheck(this, DraggableLayout);
 });
-/**
- * 计算拖动关联信息
- * @param context 上下文
- * @param context.cacheMap 缓存地图
- * @param context.draggingRect 正在拖动节点的大小以及位置
- * @param context.canBeAttachedNodes 可以被关联的节点
- * @param context.ignoreNodes 需要被忽略的节点
- * @param context.root 根节点
- * @param context.options 选项
- * @return 如果没有合法的节点关联，则返回`undefined`
+/**
+ * 计算拖动关联信息
+ * @param context 上下文
+ * @param context.cacheMap 缓存地图
+ * @param context.draggingRect 正在拖动节点的大小以及位置
+ * @param context.canBeAttachedNodes 可以被关联的节点
+ * @param context.ignoreNodes 需要被忽略的节点
+ * @param context.root 根节点
+ * @param context.options 选项
+ * @return 如果没有合法的节点关联，则返回`undefined`
  */
 _defineProperty(DraggableLayout, "calcDragAttach", function (context) {
   // 此处是为了 ts 报错
   context = context;
   throw Helper.error('DraggableLayout static calcDragAttach must be implemented');
 });
-/**
- * 计算拖动结束被放置的下标
- * @param context 上下文
- * @param context.cacheMap 缓存地图
- * @param context.attachedNodeChildren 关联节点子代
- * @param context.dropPosition 拖拽结束位置
- * @param context.root 根节点
+/**
+ * 计算拖动结束被放置的下标
+ * @param context 上下文
+ * @param context.cacheMap 缓存地图
+ * @param context.attachedNodeChildren 关联节点子代
+ * @param context.dropPosition 拖拽结束位置
+ * @param context.root 根节点
  */
 _defineProperty(DraggableLayout, "calcDropIndex", function (context) {
   // 此处是为了 ts 报错
   context = context;
   throw Helper.error('DraggableLayout static calcDropIndex must be implemented');
 });
-/**
- * 是否为合法的继承了这个类的类对象
- * @param classObject
+/**
+ * 是否为合法的继承了这个类的类对象
+ * @param classObject
  */
 _defineProperty(DraggableLayout, "isValidExtendsClass", function (classObject) {
   var shouldBeRealizedFunc = ['calcDragAttach', 'calcDropIndex'];

package/dist/components/MindGraph/core/process/visible.js

@@ -31,9 +31,9 @@ export var Visible = /*#__PURE__*/_createClass(function Visible() {
     _this.options = options;
     _this.getRootHeirOrientation = getRootHeirOrientation;
   });
-  /**
-   * 返回可见是否改变
-   * - 使用次返回值得前提是，数据没有出现改变（也就是在viewport尺寸改变或者transform时可以使用）
+  /**
+   * 返回可见是否改变
+   * - 使用次返回值得前提是，数据没有出现改变（也就是在viewport尺寸改变或者transform时可以使用）
    */
   _defineProperty(this, "end", function () {
     var visibleChange = {