ebaoferc 0.0.1 → 0.0.2-beta.0

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

@@ -0,0 +1,321 @@
+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 _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(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 { Helper } from "../../../helper";
+import { Mind } from "../../../index";
+import { DraggableLayout } from "../type";
+import { calcDragAttach } from "./calc-drag-attach";
+import { calcDropIndex } from "./calc-drop-index";
+import { getNodeCrossBoundary } from "./get-node-cross-boundary";
+export var StructuredLayout = /*#__PURE__*/function (_DraggableLayout) {
+  _inherits(StructuredLayout, _DraggableLayout);
+  var _super = _createSuper(StructuredLayout);
+  function StructuredLayout() {
+    var _this;
+    _classCallCheck(this, StructuredLayout);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _super.call.apply(_super, [this].concat(args));
+    _defineProperty(_assertThisInitialized(_this), "options", void 0);
+    _defineProperty(_assertThisInitialized(_this), "cacheMap", void 0);
+    _defineProperty(_assertThisInitialized(_this), "root", void 0);
+    _defineProperty(_assertThisInitialized(_this), "getRootHeirOrientation", void 0);
+    _defineProperty(_assertThisInitialized(_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(_assertThisInitialized(_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.structuredLayout = {
+        crossBoundary: [{
+          max: Infinity,
+          min: -Infinity
+        }, {
+          max: Infinity,
+          min: -Infinity
+        }],
+        localityRect: localityRect
+      };
+
+      // 设置子代节点
+      // 由于是深度优先遍历，并且 afterEvery 在子代遍历完成之后触发
+      // 故而，子代本身得局部矩形信息已经计算完成
+      var children = Helper.getLayoutCalcChildren(node, _this.root.node.id, _this.getRootHeirOrientation);
+
+      // 需要被计算的子代为空（被折叠或者没有子代）
+      if (children.length === 0) {
+        localityRect.x = cache.rect.width / 2;
+        localityRect.y = cache.rect.height / 2;
+        return;
+      }
+      var main = {
+        negative: 0,
+        positive: 0
+      };
+      var cross = {
+        negative: 0,
+        positive: 0
+      };
+      var vertical = _this.options.direction === Mind.Direction.y;
+
+      // 计算子代主轴范围
+      // 计算子代副轴尺寸
+      children.forEach(function (child) {
+        var childCache = _this.cacheMap.get(child.id);
+        var childLocalityRect = childCache.processCache.structuredLayout.localityRect;
+        var inParentPosition = {
+          x: 0,
+          y: 0
+        };
+        childCache.processCache.structuredLayout.inParentPosition = inParentPosition;
+        if (vertical) {
+          if (childCache.orientation === Mind.Orientation.positive) {
+            if (childLocalityRect.height > main.positive) {
+              main.positive = childLocalityRect.height;
+            }
+            inParentPosition.x = cross.positive + childLocalityRect.width / 2;
+            cross.positive += childLocalityRect.width + _this.options.nodeSeparate;
+          }
+          if (childCache.orientation === Mind.Orientation.negative) {
+            if (childLocalityRect.height > main.negative) {
+              main.negative = childLocalityRect.height;
+            }
+            inParentPosition.x = cross.negative + childLocalityRect.width / 2;
+            cross.negative += childLocalityRect.width + _this.options.nodeSeparate;
+          }
+        } else {
+          if (childCache.orientation === Mind.Orientation.positive) {
+            if (childLocalityRect.width > main.positive) {
+              main.positive = childLocalityRect.width;
+            }
+            inParentPosition.y = cross.positive + childLocalityRect.height / 2;
+            cross.positive += childLocalityRect.height + _this.options.nodeSeparate;
+          }
+          if (childCache.orientation === Mind.Orientation.negative) {
+            if (childLocalityRect.width > main.negative) {
+              main.negative = childLocalityRect.width;
+            }
+            inParentPosition.y = cross.negative + childLocalityRect.height / 2;
+            cross.negative += childLocalityRect.height + _this.options.nodeSeparate;
+          }
+        }
+      });
+
+      // 去除多余的间距
+      if (cross.positive) {
+        cross.positive -= _this.options.nodeSeparate;
+      }
+      if (cross.negative) {
+        cross.negative -= _this.options.nodeSeparate;
+      }
+
+      // 副轴尺寸
+      var crossSize = Math.max(cross.positive, cross.negative, vertical ? cache.rect.width : cache.rect.height);
+
+      // 计算节点区域坐标
+      // 主轴两侧都有节点
+      if (main.positive && main.negative) {
+        // 垂直方向渲染，y模式下 positive 渲染在上侧
+        if (vertical) {
+          localityRect.y = main.positive + _this.options.rankSeparate + cache.rect.height / 2;
+          localityRect.x = crossSize / 2;
+          localityRect.width = crossSize;
+          localityRect.height = main.positive + main.negative + cache.rect.height + 2 * _this.options.rankSeparate;
+        }
+        // 水平渲染，x模式下 positive 渲染在右侧
+        else {
+          localityRect.x = main.negative + _this.options.rankSeparate + cache.rect.width / 2;
+          localityRect.y = crossSize / 2;
+          localityRect.height = crossSize;
+          localityRect.width = main.negative + main.positive + cache.rect.width + 2 * _this.options.rankSeparate;
+        }
+      }
+      // 只有负向区域存在节点
+      else if (main.negative && !main.positive) {
+        // 节点位于最上方
+        if (vertical) {
+          localityRect.y = cache.rect.height / 2;
+          localityRect.x = crossSize / 2;
+          localityRect.width = crossSize;
+          localityRect.height = main.negative + cache.rect.height + _this.options.rankSeparate;
+        }
+        // 节点位于最右侧
+        else {
+          localityRect.x = main.negative + _this.options.rankSeparate + cache.rect.width / 2;
+          localityRect.y = crossSize / 2;
+          localityRect.height = crossSize;
+          localityRect.width = main.negative + cache.rect.width + _this.options.rankSeparate;
+        }
+      }
+      // 只有正向区域存在节点
+      else if (main.positive && !main.negative) {
+        // 节点位于最下方
+        if (vertical) {
+          localityRect.y = main.positive + _this.options.rankSeparate + cache.rect.height / 2;
+          localityRect.x = crossSize / 2;
+          localityRect.width = crossSize;
+          localityRect.height = main.positive + cache.rect.height + _this.options.rankSeparate;
+        }
+        // 节点位于最左侧
+        else {
+          localityRect.x = cache.rect.width / 2;
+          localityRect.y = crossSize / 2;
+          localityRect.height = crossSize;
+          localityRect.width = main.positive + cache.rect.width + _this.options.rankSeparate;
+        }
+      }
+
+      // 子代副轴原点偏移
+      var childCrossOriginDiff = {
+        negative: 0,
+        positive: 0
+      };
+      // 垂直方向渲染，y模式下 positive 渲染在上侧
+      if (vertical) {
+        childCrossOriginDiff.positive = localityRect.x - cross.positive / 2;
+        childCrossOriginDiff.negative = localityRect.x - cross.negative / 2;
+      }
+      // 水平渲染，x模式下 positive 渲染在右侧
+      else {
+        childCrossOriginDiff.positive = localityRect.y - cross.positive / 2;
+        childCrossOriginDiff.negative = localityRect.y - cross.negative / 2;
+      }
+
+      // 计算子代位于父级区域内的坐标
+      children.forEach(function (child) {
+        var childCache = _this.cacheMap.get(child.id);
+        var inParentPosition = childCache.processCache.structuredLayout.inParentPosition;
+        var childLocalityRect = childCache.processCache.structuredLayout.localityRect;
+        if (vertical) {
+          // y 轴正向，位于节点上方
+          if (childCache.orientation === Mind.Orientation.positive) {
+            inParentPosition.y = localityRect.y - cache.rect.height / 2 - _this.options.rankSeparate - childLocalityRect.height / 2;
+            inParentPosition.x += childCrossOriginDiff.positive;
+          }
+          // y 轴负向，位于节点下方
+          if (childCache.orientation === Mind.Orientation.negative) {
+            inParentPosition.y = localityRect.y + cache.rect.height / 2 + _this.options.rankSeparate + childLocalityRect.height / 2;
+            inParentPosition.x += childCrossOriginDiff.negative;
+          }
+        } else {
+          // x 轴，节点正向，右侧
+          if (childCache.orientation === Mind.Orientation.positive) {
+            inParentPosition.x = localityRect.x + cache.rect.width / 2 + _this.options.rankSeparate + childLocalityRect.width / 2;
+            inParentPosition.y += childCrossOriginDiff.positive;
+          }
+          // x 轴，节点负向，左侧
+          if (childCache.orientation === Mind.Orientation.negative) {
+            inParentPosition.x = localityRect.x - cache.rect.width / 2 - _this.options.rankSeparate - childLocalityRect.width / 2;
+            inParentPosition.y += childCrossOriginDiff.negative;
+          }
+        }
+      });
+    });
+    _defineProperty(_assertThisInitialized(_this), "end", function () {
+      var rootCache = _this.cacheMap.get(_this.root.node.id);
+      var rootNode = rootCache.node;
+      // // 保存整体布局尺寸
+      rootCache.layoutSize = {
+        height: rootCache.processCache.structuredLayout.localityRect.height,
+        width: rootCache.processCache.structuredLayout.localityRect.width
+      };
+      var vertical = _this.options.direction === Mind.Direction.y;
+      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.structuredLayout.localityRect.x;
+            cache.rect.y = cache.processCache.structuredLayout.localityRect.y;
+            cache.processCache.structuredLayout.origin = {
+              x: 0,
+              y: 0
+            };
+          }
+          // 广度优先遍历，故而，节点所领导的区域位于的坐标系原点已确定
+          else {
+            var parentCache = _this.cacheMap.get(cache.parent.id);
+            // 坐标系原点
+            var origin = parentCache.processCache.structuredLayout.origin;
+            // 自身所领导区域位于父区域的位置
+            var inParentPosition = cache.processCache.structuredLayout.inParentPosition;
+            // 自身所领导的区域容器矩形信息
+            var localityReact = cache.processCache.structuredLayout.localityRect;
+
+            // 节点所领导区域左上角坐标
+            // 即，领导区域的原点
+            var nodeOrigin = {
+              x: origin.x + inParentPosition.x - localityReact.width / 2,
+              y: origin.y + inParentPosition.y - localityReact.height / 2
+            };
+            cache.processCache.structuredLayout.origin = nodeOrigin;
+
+            // 根据区域原点计算出实际坐标
+            cache.rect.x = localityReact.x + nodeOrigin.x;
+            cache.rect.y = localityReact.y + nodeOrigin.y;
+          }
+          var crossBoundary = cache.processCache.structuredLayout.crossBoundary;
+          // 计算节点交叉轴范围
+          if (vertical) {
+            crossBoundary[0].min = cache.rect.x - cache.processCache.structuredLayout.localityRect.width / 2;
+            crossBoundary[0].max = cache.rect.x + cache.processCache.structuredLayout.localityRect.width / 2;
+          } else {
+            crossBoundary[0].min = cache.rect.y - cache.processCache.structuredLayout.localityRect.height / 2;
+            crossBoundary[0].max = cache.rect.y + cache.processCache.structuredLayout.localityRect.height / 2;
+          }
+
+          // 清空无用数据
+          cache.processCache.structuredLayout.inParentPosition = undefined;
+          cache.processCache.structuredLayout.localityRect = undefined;
+
+          // 折叠，则，子代无需继续计算
+          return !Helper.judgeIfAllChildFold(node, _this.root.node.id);
+        }
+      });
+
+      // 根节点交叉轴边界特殊处理
+      // 根节点折叠特殊处理
+      rootCache.processCache.structuredLayout.crossBoundary = [getNodeCrossBoundary(rootCache, (rootNode.fold || [])[0] ? [] : _this.root.negative, vertical, _this.cacheMap), getNodeCrossBoundary(rootCache, (rootNode.fold || [])[1] ? [] : _this.root.positive, vertical, _this.cacheMap)];
+    });
+    return _this;
+  }
+  return _createClass(StructuredLayout);
+}(DraggableLayout);
+_defineProperty(StructuredLayout, "calcDragAttach", calcDragAttach);
+_defineProperty(StructuredLayout, "calcDropIndex", calcDropIndex);

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

@@ -0,0 +1,44 @@
+import { Mind } from '../../index';
+export declare class DraggableLayout {
+    /**
+     * 计算拖动关联信息
+     * @param context 上下文
+     * @param context.cacheMap 缓存地图
+     * @param context.draggingRect 正在拖动节点的大小以及位置
+     * @param context.canBeAttachedNodes 可以被关联的节点
+     * @param context.ignoreNodes 需要被忽略的节点
+     * @param context.root 根节点
+     * @param context.options 选项
+     * @return 如果没有合法的节点关联，则返回`undefined`
+     */
+    static calcDragAttach: (context: {
+        cacheMap: Mind.CacheMap;
+        draggingRect: Mind.Coordinate & Mind.Size;
+        canBeAttachedNodes: Mind.Node[];
+        ignoreNodes: Mind.Node[];
+        root: Mind.Root;
+        options: Required<Mind.Options>;
+    }) => Mind.DragAttach | undefined;
+    /**
+     * 计算拖动结束被放置的下标
+     * @param context 上下文
+     * @param context.cacheMap 缓存地图
+     * @param context.attachedNodeChildren 关联节点子代
+     * @param context.dropPosition 拖拽结束位置
+     * @param context.root 根节点
+     */
+    static calcDropIndex: (context: {
+        cacheMap: Mind.CacheMap;
+        attachedNodeChildren: Mind.Node[] | undefined;
+        dropPosition: Mind.Coordinate;
+        attachedNode: Mind.Node;
+        dragNode: Mind.Node;
+        root: Mind.Root;
+        options: Mind.Options;
+    }) => number;
+    /**
+     * 是否为合法的继承了这个类的类对象
+     * @param classObject
+     */
+    static isValidExtendsClass: (classObject: any) => any;
+}

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

@@ -0,0 +1,51 @@
+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 { Helper } from "../../helper";
+// @ts-ignore
+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`
+ */
+_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 根节点
+ */
+_defineProperty(DraggableLayout, "calcDropIndex", function (context) {
+  // 此处是为了 ts 报错
+  context = context;
+  throw Helper.error('DraggableLayout static calcDropIndex must be implemented');
+});
+/**
+ * 是否为合法的继承了这个类的类对象
+ * @param classObject
+ */
+_defineProperty(DraggableLayout, "isValidExtendsClass", function (classObject) {
+  var shouldBeRealizedFunc = ['calcDragAttach', 'calcDropIndex'];
+  return classObject && shouldBeRealizedFunc.every(function (func) {
+    return classObject[func];
+  });
+});

package/dist/components/MindGraph/core/process/line.d.ts

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

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

@@ -0,0 +1,69 @@
+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 { Helper } from "../helper";
+import { Mind } from "../index";
+export var Line = /*#__PURE__*/_createClass(function Line() {
+  var _this = this;
+  _classCallCheck(this, Line);
+  _defineProperty(this, "cacheMap", void 0);
+  _defineProperty(this, "options", void 0);
+  _defineProperty(this, "root", void 0);
+  _defineProperty(this, "getRootHeirOrientation", void 0);
+  _defineProperty(this, "start", function (context) {
+    var cacheMap = context.cacheMap,
+      options = context.options,
+      root = context.root,
+      getRootHeirOrientation = context.getRootHeirOrientation;
+    _this.cacheMap = cacheMap;
+    _this.options = options;
+    _this.root = root;
+    _this.getRootHeirOrientation = getRootHeirOrientation;
+  });
+  _defineProperty(this, "end", function () {
+    Helper.breadthFirstWalkTree(_this.cacheMap.get(_this.root.node.id).node, {
+      after: function after() {},
+      before: function before(node) {
+        var cache = _this.cacheMap.get(node.id);
+        if (!cache || Helper.judgeIfHeirAndFold(node, cache.parent, _this.root, _this.getRootHeirOrientation)) {
+          return false;
+        }
+        if (cache.parent) {
+          var parentCache = _this.cacheMap.get(cache.parent.id);
+          if (_this.options.direction === Mind.Direction.x) {
+            cache.line.source.y = parentCache.rect.y;
+            cache.line.target.y = cache.rect.y;
+            // 节点位于父级右侧
+            if (cache.orientation === Mind.Orientation.positive) {
+              cache.line.source.x = parentCache.rect.x + parentCache.rect.width / 2;
+              cache.line.target.x = cache.rect.x - cache.rect.width / 2;
+            }
+            // 节点位于父级左侧
+            else {
+              cache.line.source.x = parentCache.rect.x - parentCache.rect.width / 2;
+              cache.line.target.x = cache.rect.x + cache.rect.width / 2;
+            }
+          } else {
+            cache.line.source.x = parentCache.rect.x;
+            cache.line.target.x = cache.rect.x;
+            // 节点位于上方
+            if (cache.orientation === Mind.Orientation.positive) {
+              cache.line.source.y = parentCache.rect.y - parentCache.rect.height / 2;
+              cache.line.target.y = cache.rect.y + cache.rect.height / 2;
+            }
+            // 节点位于下方
+            else {
+              cache.line.source.y = parentCache.rect.y + parentCache.rect.height / 2;
+              cache.line.target.y = cache.rect.y - cache.rect.height / 2;
+            }
+          }
+        }
+        return !Helper.judgeIfAllChildFold(node, _this.root.node.id);
+      }
+    });
+  });
+});

package/dist/components/MindGraph/core/process/node-valid.d.ts

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

package/dist/components/MindGraph/core/process/node-valid.js

@@ -0,0 +1,35 @@
+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 { Helper } from "../helper";
+export var NodeValid = /*#__PURE__*/_createClass(function NodeValid() {
+  var _this = this;
+  _classCallCheck(this, NodeValid);
+  _defineProperty(this, "root", void 0);
+  _defineProperty(this, "start", function (context) {
+    var root = context.root;
+    _this.root = root;
+  });
+  _defineProperty(this, "every", function (context) {
+    var node = context.cache.node;
+    if (!node.id) {
+      throw Helper.error('node id can not be empty or undefined');
+    }
+    if (!node.sizeof) {
+      throw Helper.error('node sizeof function can not be undefined');
+    }
+    if (_this.root.node.id === node.id) {
+      if (typeof node.fold !== 'undefined' && _typeof(node.fold) !== 'object') {
+        throw Helper.error('root node fold should be undefined or array');
+      }
+    } else {
+      if (typeof node.fold !== 'undefined' && typeof node.fold !== 'boolean') {
+        throw Helper.error('normal node fold should be undefined or boolean');
+      }
+    }
+  });
+});

package/dist/components/MindGraph/core/process/orientation.d.ts

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

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

@@ -0,0 +1,40 @@
+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 { Mind } from "../index";
+export var Orientation = /*#__PURE__*/_createClass(function Orientation() {
+  var _this = this;
+  _classCallCheck(this, Orientation);
+  _defineProperty(this, "root", void 0);
+  _defineProperty(this, "getRootHeirOrientation", void 0);
+  _defineProperty(this, "cacheMap", void 0);
+  _defineProperty(this, "start", function (context) {
+    var root = context.root,
+      getRootHeirOrientation = context.getRootHeirOrientation,
+      cacheMap = context.cacheMap;
+    _this.root = root;
+    _this.getRootHeirOrientation = getRootHeirOrientation;
+    _this.cacheMap = cacheMap;
+  });
+  _defineProperty(this, "every", function (context) {
+    var cache = context.cache;
+
+    // 根节点
+    if (!cache.parent) {
+      cache.orientation = Mind.Orientation.root;
+    }
+    // 根节点直系子代
+    else if (cache.parent.id === _this.root.node.id) {
+      cache.orientation = _this.getRootHeirOrientation(cache.node.id);
+    }
+    // 非根节点直系子代，继承父级
+    // 由于是深度优先遍历，故而父节点 cache 早已设置完全
+    else {
+      cache.orientation = _this.cacheMap.get(cache.parent.id).orientation;
+    }
+  });
+});

package/dist/components/MindGraph/core/process/size.d.ts

@@ -0,0 +1,4 @@
+import { Process } from './index';
+export declare class Size implements Process.Lifecycle {
+    every: (context: Process.EveryContext) => void;
+}

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

@@ -0,0 +1,16 @@
+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); }
+export var Size = /*#__PURE__*/_createClass(function Size() {
+  _classCallCheck(this, Size);
+  _defineProperty(this, "every", function (context) {
+    var cache = context.cache;
+    var size = cache.node.sizeof();
+    cache.rect.width = size.width;
+    cache.rect.height = size.height;
+  });
+});

package/dist/components/MindGraph/core/process/visible.d.ts

@@ -0,0 +1,16 @@
+import { Mind } from '../index';
+import { Process } from './index';
+export declare class Visible implements Process.Lifecycle<void, void, void, Mind.Visible> {
+    private viewport;
+    private transform;
+    private root;
+    private cacheMap;
+    private options;
+    private getRootHeirOrientation;
+    start: (context: Process.StartContext) => void;
+    /**
+     * 返回可见是否改变
+     * - 使用次返回值得前提是，数据没有出现改变（也就是在viewport尺寸改变或者transform时可以使用）
+     */
+    end: () => Mind.Visible;
+}