ebaoferc 0.0.1 → 0.0.2-beta.1

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

@@ -0,0 +1,20 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+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(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import * as dagre from 'dagre';
+import { Mind } from "../../index";
+export var generateDagreGraphic = function generateDagreGraphic(options) {
+  var DirectionToRankdir = _defineProperty(_defineProperty({}, Mind.Direction.x, 'LR'), Mind.Direction.y, 'BT');
+  var graphic = new dagre.graphlib.Graph();
+  graphic.setGraph({
+    nodesep: options.nodeSeparate,
+    rankdir: DirectionToRankdir[options.direction],
+    ranker: 'tight-tree',
+    ranksep: options.rankSeparate
+  });
+  graphic.setDefaultEdgeLabel(function () {
+    return {};
+  });
+  return graphic;
+};

package/dist/components/MindGraph/core/process/layout/descendant-center.d.ts

@@ -0,0 +1,10 @@
+import { Process } from '../index';
+export declare class DescendantCenterLayout implements Process.Lifecycle {
+    private options;
+    private cacheMap;
+    private root;
+    private getRootHeirOrientation;
+    start: (context: Process.StartContext) => void;
+    afterEvery: (context: Process.EveryContext) => void;
+    end: () => void;
+}

package/dist/components/MindGraph/core/process/layout/descendant-center.js

@@ -0,0 +1,146 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+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(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+// 子代整体居中对齐布局
+// 算法默认会将同一rank(层级)的直系子代，在垂直于布局的方向上中心对齐
+// 故而通过递归，将所有后代统一视作一个整体计算尺寸，得出偏移
+// 即可实现后代居中功能
+import * as dagre from 'dagre';
+import { Helper } from "../../helper";
+import { Mind } from "../../index";
+import { generateDagreGraphic } from "./dagre";
+export var DescendantCenterLayout = /*#__PURE__*/_createClass(function DescendantCenterLayout() {
+  var _this = this;
+  _classCallCheck(this, DescendantCenterLayout);
+  _defineProperty(this, "options", void 0);
+  _defineProperty(this, "cacheMap", void 0);
+  _defineProperty(this, "root", void 0);
+  _defineProperty(this, "getRootHeirOrientation", void 0);
+  _defineProperty(this, "start", function (context) {
+    var options = context.options,
+      cacheMap = context.cacheMap,
+      root = context.root,
+      getRootHeirOrientation = context.getRootHeirOrientation;
+    _this.root = root;
+    _this.options = options;
+    _this.cacheMap = cacheMap;
+    _this.getRootHeirOrientation = getRootHeirOrientation;
+  });
+  // 递归返回，子节点处理完成
+  _defineProperty(this, "afterEvery", function (context) {
+    var cache = context.cache;
+    var node = cache.node;
+    // 区域矩形初始化为本身尺寸，用作计算
+    var localityRect = {
+      height: cache.rect.height,
+      width: cache.rect.width,
+      x: 0,
+      y: 0
+    };
+    cache.processCache.descendantCenterLayout = {
+      localityRect: localityRect
+    };
+    // 设置子代节点
+    // 由于是深度优先遍历，并且 afterEvery 在子代遍历完成之后触发
+    // 故而，子代本身得局部矩形信息已经计算完成
+    var children = Helper.getLayoutCalcChildren(node, _this.root.node.id, _this.getRootHeirOrientation);
+    // 子代为空，或者子代需要折叠，则，本身尺寸作为区域尺寸，x y 直接居中即可
+    if (children.length === 0) {
+      localityRect.x = cache.rect.width / 2;
+      localityRect.y = cache.rect.height / 2;
+      return;
+    }
+
+    // 创建一个局部的计算图
+    var graphic = generateDagreGraphic(_this.options);
+    // 设置区域根节点
+    graphic.setNode(node.id, localityRect);
+    children.forEach(function (child) {
+      var cache = _this.cacheMap.get(child.id);
+      // 子节点区域矩形信息
+      var localityRect = cache.processCache.descendantCenterLayout.localityRect;
+      // 子节点区域在父级区域矩形信息中的位置信息
+      var localityRectInParent = {
+        height: localityRect.height,
+        width: localityRect.width,
+        x: 0,
+        y: 0
+      };
+      cache.processCache.descendantCenterLayout.localityRectInParent = localityRectInParent;
+      graphic.setNode(child.id, localityRectInParent);
+      if (cache.orientation === Mind.Orientation.positive) {
+        graphic.setEdge(node.id, child.id);
+      } else {
+        graphic.setEdge(child.id, node.id);
+      }
+    });
+    dagre.layout(graphic);
+    var graph = graphic.graph();
+    // 回填区域尺寸数据
+    localityRect.width = graph.width;
+    localityRect.height = graph.height;
+  });
+  _defineProperty(this, "end", function () {
+    var rootCache = _this.cacheMap.get(_this.root.node.id);
+    var rootNode = rootCache.node;
+    // 保存整体布局尺寸
+    rootCache.layoutSize = {
+      height: rootCache.processCache.descendantCenterLayout.localityRect.height,
+      width: rootCache.processCache.descendantCenterLayout.localityRect.width
+    };
+    Helper.breadthFirstWalkTree(rootNode, {
+      after: function after() {
+        // default
+      },
+      before: function before(node) {
+        var cache = _this.cacheMap.get(node.id);
+        if (!cache || Helper.judgeIfHeirAndFold(node, cache.parent, _this.root, _this.getRootHeirOrientation)) {
+          return false;
+        }
+
+        // 根节点，无父级，自身位置就是正确位置，原点位置为（0,0）
+        if (!cache.parent) {
+          cache.rect.x = cache.processCache.descendantCenterLayout.localityRect.x;
+          cache.rect.y = cache.processCache.descendantCenterLayout.localityRect.y;
+          cache.processCache.descendantCenterLayout.origin = {
+            x: 0,
+            y: 0
+          };
+        }
+        // 广度优先遍历，故而，节点所领导的区域位于的坐标系原点已确定
+        else {
+          var parentCache = _this.cacheMap.get(cache.parent.id);
+          // 坐标系原点
+          var origin = parentCache.processCache.descendantCenterLayout.origin;
+          // 自身所领导的区域容器位于父容器的矩形信息
+          var localityRectInParent = cache.processCache.descendantCenterLayout.localityRectInParent;
+          // 自身所领导的区域容器矩形信息
+          var localityReact = cache.processCache.descendantCenterLayout.localityRect;
+
+          // 节点所领导区域左上角坐标
+          // 即，领导区域的原点
+          var nodeOrigin = {
+            x: origin.x + localityRectInParent.x - localityRectInParent.width / 2,
+            y: origin.y + localityRectInParent.y - localityRectInParent.height / 2
+          };
+          cache.processCache.descendantCenterLayout.origin = nodeOrigin;
+
+          // 根据区域原点计算出实际坐标
+          cache.rect.x = localityReact.x + nodeOrigin.x;
+          cache.rect.y = localityReact.y + nodeOrigin.y;
+
+          // 清空无用数据
+          cache.processCache.descendantCenterLayout.localityRectInParent = undefined;
+          cache.processCache.descendantCenterLayout.localityRect = undefined;
+        }
+
+        // 折叠，则，子代无需继续计算
+        return !Helper.judgeIfAllChildFold(node, _this.root.node.id);
+      }
+    });
+  });
+});

package/dist/components/MindGraph/core/process/layout/heir-center.d.ts

@@ -0,0 +1,10 @@
+import { Process } from '../index';
+export declare class HeirCenterLayout implements Process.Lifecycle {
+    private graphic;
+    private cacheMap;
+    private root;
+    private options;
+    start: (context: Process.StartContext) => void;
+    every: (context: Process.EveryContext) => void;
+    end: () => void;
+}

package/dist/components/MindGraph/core/process/layout/heir-center.js

@@ -0,0 +1,52 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+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(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+// 直系子代居中对齐布局
+import * as dagre from 'dagre';
+import { Mind } from "../../index";
+import { generateDagreGraphic } from "./dagre";
+export var HeirCenterLayout = /*#__PURE__*/_createClass(function HeirCenterLayout() {
+  var _this = this;
+  _classCallCheck(this, HeirCenterLayout);
+  _defineProperty(this, "graphic", void 0);
+  _defineProperty(this, "cacheMap", void 0);
+  _defineProperty(this, "root", void 0);
+  _defineProperty(this, "options", void 0);
+  _defineProperty(this, "start", function (context) {
+    var options = context.options,
+      root = context.root,
+      cacheMap = context.cacheMap;
+    _this.root = root;
+    _this.cacheMap = cacheMap;
+    _this.options = options;
+    _this.graphic = generateDagreGraphic(options);
+  });
+  _defineProperty(this, "every", function (context) {
+    var cache = context.cache;
+    var node = cache.node,
+      parent = cache.parent;
+    _this.graphic.setNode(node.id, cache.rect);
+    if (parent) {
+      if (cache.orientation === Mind.Orientation.positive) {
+        _this.graphic.setEdge(parent.id, node.id);
+      } else {
+        _this.graphic.setEdge(node.id, parent.id);
+      }
+    }
+  });
+  _defineProperty(this, "end", function () {
+    // 计算关系
+    dagre.layout(_this.graphic);
+    var rootCache = _this.cacheMap.get(_this.root.node.id);
+    // 存储整体布局尺寸
+    var graph = _this.graphic.graph();
+    rootCache.layoutSize = {
+      height: graph.height,
+      width: graph.width
+    };
+  });
+});

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

@@ -0,0 +1,3 @@
+export { DescendantCenterLayout } from './descendant-center';
+export { HeirCenterLayout } from './heir-center';
+export { StructuredLayout } from './structured';

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

@@ -0,0 +1,3 @@
+export { DescendantCenterLayout } from "./descendant-center";
+export { HeirCenterLayout } from "./heir-center";
+export { StructuredLayout } from "./structured";

package/dist/components/MindGraph/core/process/layout/structured/calc-drag-attach.d.ts

@@ -0,0 +1,2 @@
+import { DraggableLayout } from '../type';
+export declare const calcDragAttach: typeof DraggableLayout.calcDragAttach;

package/dist/components/MindGraph/core/process/layout/structured/calc-drag-attach.js

@@ -0,0 +1,172 @@
+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 { Helper } from "../../../helper";
+import { Mind } from "../../../index";
+export var calcDragAttach = function calcDragAttach(context) {
+  var options = context.options,
+    cacheMap = context.cacheMap,
+    root = context.root,
+    canBeAttachedNodes = context.canBeAttachedNodes,
+    draggingRect = context.draggingRect,
+    ignoreNodes = context.ignoreNodes;
+  var vertical = options.direction === Mind.Direction.y;
+  var orientation = Mind.Orientation.root;
+  var rootRect = cacheMap.get(root.node.id).rect;
+  var targetLinkPoint = {
+    x: 0,
+    y: 0
+  };
+  if (vertical) {
+    targetLinkPoint.x = draggingRect.x;
+    // 上部/正向区域
+    if (draggingRect.y + draggingRect.height / 2 < rootRect.y - rootRect.height / 2) {
+      orientation = Mind.Orientation.positive;
+      targetLinkPoint.y = draggingRect.y + draggingRect.height / 2;
+    }
+    // 下部/负向区域
+    else if (draggingRect.y - draggingRect.height / 2 > rootRect.y + rootRect.height / 2) {
+      orientation = Mind.Orientation.negative;
+      targetLinkPoint.y = draggingRect.y - draggingRect.height / 2;
+    }
+  } else {
+    targetLinkPoint.y = draggingRect.y;
+    // 右侧/正向区域
+    if (draggingRect.x - draggingRect.width / 2 > rootRect.x + rootRect.width / 2) {
+      orientation = Mind.Orientation.positive;
+      targetLinkPoint.x = draggingRect.x - draggingRect.width / 2;
+    }
+    // 左侧/负向区域
+    else if (draggingRect.x + draggingRect.width / 2 < rootRect.x - rootRect.width / 2) {
+      orientation = Mind.Orientation.negative;
+      targetLinkPoint.x = draggingRect.x + draggingRect.width / 2;
+    }
+  }
+
+  // 没有处于有效的可链接区域，返回undefined
+  if (orientation === Mind.Orientation.root) {
+    return undefined;
+  }
+  var linkNode = undefined;
+  var linkPoint = undefined;
+  var minMainDistance = Infinity;
+  var _iterator = _createForOfIteratorHelper(canBeAttachedNodes),
+    _step;
+  try {
+    var _loop = function _loop() {
+        var node = _step.value;
+        // 过滤忽略节点
+        if (ignoreNodes.find(function (item) {
+          return item.id === node.id;
+        })) {
+          return 0; // continue
+        }
+        var cache = cacheMap.get(node.id);
+        if (!cache) {
+          return 0; // continue
+        }
+
+        // 只有位于同一渲染区域才需要计算
+        if (cache.orientation !== Mind.Orientation.root && cache.orientation !== orientation) {
+          return 0; // continue
+        }
+        var rect = cache.rect;
+        var canBeLinkPoint = {
+          x: 0,
+          y: 0
+        };
+        // 计算被链接点坐标
+        if (vertical) {
+          canBeLinkPoint.x = rect.x;
+
+          // 目标节点位于正向区域/根节点上方
+          if (orientation === Mind.Orientation.positive) {
+            canBeLinkPoint.y = rect.y - rect.height / 2;
+            if (canBeLinkPoint.y < targetLinkPoint.y) {
+              return 0; // continue
+            }
+          } else {
+            canBeLinkPoint.y = rect.y + rect.height / 2;
+            if (canBeLinkPoint.y > targetLinkPoint.y) {
+              return 0; // continue
+            }
+          }
+        } else {
+          canBeLinkPoint.y = rect.y;
+
+          // 目标节点位于正向区域/根节点右侧
+          if (orientation === Mind.Orientation.positive) {
+            canBeLinkPoint.x = rect.x + rect.width / 2;
+            if (canBeLinkPoint.x > targetLinkPoint.x) {
+              return 0; // continue
+            }
+          } else {
+            canBeLinkPoint.x = rect.x - rect.width / 2;
+            if (canBeLinkPoint.x < targetLinkPoint.x) {
+              return 0; // continue
+            }
+          }
+        }
+        var crossBoundary = cache.processCache.structuredLayout.crossBoundary[0];
+        // 当前节点为根节点
+        if (root.node.id === node.id) {
+          crossBoundary = orientation === Mind.Orientation.negative ? cache.processCache.structuredLayout.crossBoundary[0] : cache.processCache.structuredLayout.crossBoundary[1];
+        }
+        // 限定交叉轴范围
+        var targetCrossValue = vertical ? draggingRect.x : draggingRect.y;
+        if (targetCrossValue < crossBoundary.min - options.nodeSeparate / 2 || targetCrossValue > crossBoundary.max + options.nodeSeparate / 2) {
+          return 0; // continue
+        }
+
+        // 主轴距离最近
+        var mainDistance = vertical ? Math.abs(canBeLinkPoint.y - targetLinkPoint.y) : Math.abs(canBeLinkPoint.x - targetLinkPoint.x);
+        // 主轴距离最近
+        if (mainDistance < minMainDistance) {
+          minMainDistance = mainDistance;
+          linkNode = node;
+          linkPoint = canBeLinkPoint;
+        }
+      },
+      _ret;
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      _ret = _loop();
+      if (_ret === 0) continue;
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  if (linkPoint && linkNode) {
+    var children = linkNode.children || [];
+
+    // 根节点折叠特殊处理
+    if (linkNode.id === root.node.id) {
+      var fold = root.node.fold || [];
+      // positive 没被折叠，此时镜像节点位于 positive,检查是否为视觉叶节点使用 positive 子代
+      if (!fold[1] && orientation === Mind.Orientation.positive) {
+        children = root.positive || [];
+      }
+      // negative 没被折叠，此时镜像节点位于 negative,检查是否为视觉叶节点使用 negative 子代
+      else if (!fold[0] && orientation === Mind.Orientation.negative) {
+        children = root.negative || [];
+      } else {
+        children = [];
+      }
+    }
+
+    // 视觉叶节点，主轴距离限制，超出一定比例则视作无效
+    if (Helper.judgeIfVisualLeaf(linkNode, children) && minMainDistance > options.rankSeparate * 2) {
+      return undefined;
+    }
+    return {
+      link: {
+        source: linkPoint,
+        target: targetLinkPoint
+      },
+      node: linkNode,
+      orientation: orientation
+    };
+  }
+  return undefined;
+};

package/dist/components/MindGraph/core/process/layout/structured/calc-drop-index.d.ts

@@ -0,0 +1,2 @@
+import { DraggableLayout } from '../type';
+export declare const calcDropIndex: typeof DraggableLayout.calcDropIndex;

package/dist/components/MindGraph/core/process/layout/structured/calc-drop-index.js

@@ -0,0 +1,38 @@
+import { Mind } from "../../../index";
+export var calcDropIndex = function calcDropIndex(context) {
+  var attachedNodeChildren = context.attachedNodeChildren,
+    dropPosition = context.dropPosition,
+    options = context.options,
+    cacheMap = context.cacheMap,
+    dragNode = context.dragNode,
+    attachedNode = context.attachedNode;
+  // 节点没有子代，则，拖拽节点自动为第一个节点
+  // 当子代被折叠的时候，自动作为第一个节点
+  if (!attachedNodeChildren || attachedNodeChildren.length === 0 || attachedNode.fold) {
+    return 0;
+  }
+  var vertical = options.direction === Mind.Direction.y;
+  var dragNodeJudgeValue = vertical ? dropPosition.x : dropPosition.y;
+  var getNodeJudgeValue = function getNodeJudgeValue(id) {
+    var cache = cacheMap.get(id);
+    var rect = cache.rect;
+    return vertical ? rect.x : rect.y;
+  };
+
+  // 处理边界情况
+  if (dragNodeJudgeValue <= getNodeJudgeValue(attachedNodeChildren[0].id)) {
+    return attachedNodeChildren[0].id === dragNode.id ? -1 : 0;
+  }
+  if (dragNodeJudgeValue >= getNodeJudgeValue(attachedNodeChildren[attachedNodeChildren.length - 1].id)) {
+    return attachedNodeChildren[attachedNodeChildren.length - 1].id === dragNode.id ? -1 : attachedNodeChildren.length;
+  }
+  for (var index = 1; index < attachedNodeChildren.length; index++) {
+    if (dragNodeJudgeValue >= getNodeJudgeValue(attachedNodeChildren[index - 1].id) && dragNodeJudgeValue <= getNodeJudgeValue(attachedNodeChildren[index].id)) {
+      if (attachedNodeChildren[index - 1].id === dragNode.id || attachedNodeChildren[index].id === dragNode.id) {
+        return -1;
+      }
+      return index;
+    }
+  }
+  return -1;
+};

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

@@ -0,0 +1,10 @@
+import { Mind } from '../../../index';
+/**
+ * 获取节点交叉轴边界
+ * - 如果存在视觉子代，请保证视觉子代边界计算完成
+ * @param cache
+ * @param children
+ * @param vertical
+ * @param cacheMap
+ */
+export declare const getNodeCrossBoundary: (cache: Mind.NodeCache, children: Mind.Node[] | undefined, vertical: boolean, cacheMap: Mind.CacheMap) => Mind.Range<number>;

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

@@ -0,0 +1,35 @@
+import { Helper } from "../../../helper";
+/**
+ * 获取节点交叉轴边界
+ * - 如果存在视觉子代，请保证视觉子代边界计算完成
+ * @param cache
+ * @param children
+ * @param vertical
+ * @param cacheMap
+ */
+export var getNodeCrossBoundary = function getNodeCrossBoundary(cache, children, vertical, cacheMap) {
+  var boundary = {
+    max: Infinity,
+    min: -Infinity
+  };
+  var selfBoundary = {
+    max: Infinity,
+    min: -Infinity
+  };
+  if (vertical) {
+    selfBoundary.min = cache.rect.x - cache.rect.width / 2;
+    selfBoundary.max = cache.rect.x + cache.rect.width / 2;
+  } else {
+    selfBoundary.min = cache.rect.y - cache.rect.height / 2;
+    selfBoundary.max = cache.rect.y + cache.rect.height / 2;
+  }
+
+  // 视觉上的叶节点
+  if (Helper.judgeIfVisualLeaf(cache.node, children)) {
+    return selfBoundary;
+  } else {
+    boundary.min = Math.min(cacheMap.get(children[0].id).processCache.structuredLayout.crossBoundary[0].min, selfBoundary.min);
+    boundary.max = Math.max(cacheMap.get(children[children.length - 1].id).processCache.structuredLayout.crossBoundary[0].max, selfBoundary.max);
+  }
+  return boundary;
+};

package/dist/components/MindGraph/core/process/layout/structured/index.d.ts

@@ -0,0 +1,13 @@
+import { Process } from '../../index';
+import { DraggableLayout } from '../type';
+export declare class StructuredLayout extends DraggableLayout implements Process.Lifecycle {
+    private options;
+    private cacheMap;
+    private root;
+    private getRootHeirOrientation;
+    start: (context: Process.StartContext) => void;
+    afterEvery: (context: Process.EveryContext) => void;
+    end: () => void;
+    static calcDragAttach: typeof DraggableLayout.calcDragAttach;
+    static calcDropIndex: typeof DraggableLayout.calcDropIndex;
+}