ebaoferc 0.0.1 → 0.0.2-beta.1

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

@@ -0,0 +1,423 @@
+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 ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+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 { merge, throttle } from 'lodash';
+import { WithDefault } from "../default";
+import { Render } from "../render";
+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 配置参数
+ */
+function Graphic(viewport, _container, _options) {
+  var _this = this;
+  _classCallCheck(this, Graphic);
+  /**
+   * 节点相关信息缓存，树形结构拍平
+   */
+  _defineProperty(this, "cacheMap", new Map());
+  _defineProperty(this, "options", void 0);
+  _defineProperty(this, "container", void 0);
+  _defineProperty(this, "viewport", void 0);
+  _defineProperty(this, "transform", WithDefault.transform());
+  _defineProperty(this, "root", void 0);
+  _defineProperty(this, "anchor", void 0);
+  _defineProperty(this, "resizeObserver", void 0);
+  _defineProperty(this, "unbindCache", []);
+  _defineProperty(this, "zoom", void 0);
+  /**
+   * 同步 options 中的 zoom extent
+   */
+  _defineProperty(this, "syncZoomExtentOptions", function () {
+    _this.zoom.syncZoomExtentOptions({
+      options: _this.options
+    });
+  });
+  /**
+   * 获取当前可见的节点
+   */
+  _defineProperty(this, "getVisibleNodes", function () {
+    var nodes = [];
+    for (var _i = 0, _Array$from = Array.from(_this.cacheMap.values()); _i < _Array$from.length; _i++) {
+      var cache = _Array$from[_i];
+      if (cache.visible.node) {
+        // cache 中根节点 node 是源数据的 copy，故而需要特殊处理
+        if (_this.root && cache.node.id === _this.root.node.id) {
+          nodes.push(_this.root.node);
+        } else {
+          nodes.push(cache.node);
+        }
+      }
+    }
+    return nodes;
+  });
+  /**
+   * 获取节点定位锚点（左上角）位置，可在节点绘制的时候确定其位置
+   * - 推荐所有节点使用`position:absolute;left:0;top:0;`并且配合`transform`来定位，避免出现绘制异常
+   * @param id 节点对应id
+   */
+  _defineProperty(this, "getNodeAnchorCoordinate", function (id) {
+    var cache = _this.cacheMap.get(id);
+    if (!cache) {
+      return undefined;
+    } else {
+      return {
+        x: cache.rect.x - cache.rect.width / 2,
+        y: cache.rect.y - cache.rect.height / 2
+      };
+    }
+  });
+  // 绑定监听事件
+  _defineProperty(this, "bindEventListener", function () {
+    // 注销之前的事件绑定
+    _this.unbind();
+    // 上下文菜单触发事件
+    var onContextMenu = function onContextMenu(e) {
+      _this.options.event.onViewportContextMenu(e);
+      // 禁止弹出默认菜单
+      e.preventDefault();
+    };
+    // 视窗右键菜单操作
+    _this.viewport.addEventListener('contextmenu', onContextMenu);
+    _this.unbindCache.push(function () {
+      _this.viewport.removeEventListener('contextmenu', onContextMenu);
+    });
+
+    // 绑定 zoom 监听
+    // 此处再次封装 event 是为了在 onZoomEventTrigger 内容改变的时候，依旧可以正确触发事件
+    _this.zoom.bind(_this.onTransform, {
+      end: function end(e) {
+        return _this.options.event.onZoomEventTrigger.end(e);
+      },
+      start: function start(e) {
+        return _this.options.event.onZoomEventTrigger.start(e);
+      },
+      zoom: function zoom(e) {
+        return _this.options.event.onZoomEventTrigger.zoom(e);
+      }
+    });
+    _this.unbindCache.push(_this.zoom.destroy);
+
+    // 绑定尺寸改变监听事件
+    if (ResizeObserver) {
+      _this.resizeObserver = new ResizeObserver(_this.onViewportResize);
+      _this.resizeObserver.observe(_this.viewport);
+      _this.unbindCache.push(function () {
+        return _this.resizeObserver.unobserve(_this.viewport);
+      });
+    }
+  });
+  _defineProperty(this, "onTransform", function (transform) {
+    _this.transform = transform;
+    // 直接修改 dom style
+    _this.container.style.transform = "translateX(".concat(transform.x, "px) translateY(").concat(transform.y, "px) scale(").concat(transform.scale, ")");
+    _this.container.style.transformOrigin = 'left top';
+
+    // 刷新可视区域
+    _this.refreshVisible();
+    // 回调事件，通知外部 transform 改变
+    _this.options.callback.onTransformChange(transform);
+  });
+  /**
+   * - 计算节点可见是否改变，如改变，则通知外部
+   * - 重渲染连线，销毁不必要的连线
+   */
+  _defineProperty(this, "refreshVisible", function () {
+    if (_this.cacheMap.size) {
+      var visibleChange = _this.calcVisible();
+      // 节点可见性改变，通知外部重新渲染
+      if (visibleChange.node) {
+        _this.options.callback.onNodeVisibleChange(_this.getVisibleNodes());
+      }
+      // 连线可见性出现改变，则重新绘制线条
+      if (visibleChange.lineAttachParent) {
+        _this.connect();
+      }
+    }
+  });
+  _defineProperty(this, "throttleRefreshVisible", throttle(this.refreshVisible, 100));
+  /**
+   * 视窗尺寸变化
+   * @private
+   */
+  _defineProperty(this, "onViewportResize", function () {
+    _this.zoom.syncZoomExtent({
+      height: _this.viewport.clientHeight,
+      width: _this.viewport.clientWidth
+    });
+    // 避免频繁的刷新可视区域导致界面卡顿
+    _this.throttleRefreshVisible();
+  });
+  /**
+   * 注销事件绑定
+   * - 请在销毁组件之前调用
+   */
+  _defineProperty(this, "unbind", function () {
+    _this.unbindCache.forEach(function (dispose) {
+      return dispose();
+    });
+    _this.unbindCache = [];
+  });
+  /**
+   * 判断节点是否可视
+   * @param id 节点对应id
+   */
+  _defineProperty(this, "judgeNodeVisible", function (id) {
+    var cache = _this.cacheMap.get(id);
+    if (cache) {
+      return cache.visible.node;
+    } else {
+      return false;
+    }
+  });
+  /**
+   * 设定 `options`
+   * - 函数不会自动执行重渲染，如果改变的`options`需要重新计算布局等操作，推荐使用 `setData` 驱动数据重渲染
+   * @param options 设定选项
+   * @param isMerge 是否与之前的`options`做合并操作
+   */
+  _defineProperty(this, "setOptions", function (options) {
+    var isMerge = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    if (isMerge) {
+      _this.options = merge({}, _this.options, options || {});
+    } else {
+      _this.options = WithDefault.options(options);
+    }
+    _this.syncZoomExtentOptions();
+  });
+  /**
+   * 生成拖动控制器
+   * - 根节点不可拖拽
+   * - 当前暂时只有`Mind.ChildAlignMode.structured`布局算法支持拖拽功能
+   * @param drag 拖动节点node对象或id
+   * @return
+   * - 当root（没有调用`setData`）不存在时，或者`drag`为根节点时，返回`undefined`
+   * - 正常情况返回 `Drag` 类对象
+   */
+  _defineProperty(this, "dragControllerBuilder", function (drag) {
+    var _this$cacheMap$get;
+    var dragNode = typeof drag === 'string' ? (_this$cacheMap$get = _this.cacheMap.get(drag)) === null || _this$cacheMap$get === void 0 ? void 0 : _this$cacheMap$get.node : drag;
+    if (_this.root && dragNode && dragNode.id !== _this.root.node.id) {
+      return new Drag({
+        cacheMap: _this.cacheMap,
+        container: _this.container,
+        dragNode: dragNode,
+        options: _this.options,
+        root: _this.root
+      });
+    } else {
+      return undefined;
+    }
+  });
+  /**
+   * 获取渲染层尺寸
+   */
+  _defineProperty(this, "getLayoutSize", function () {
+    var _this$root;
+    var root = _this.cacheMap.get(((_this$root = _this.root) === null || _this$root === void 0 || (_this$root = _this$root.node) === null || _this$root === void 0 ? void 0 : _this$root.id) || '');
+    if (root) {
+      return root.layoutSize;
+    } else {
+      return undefined;
+    }
+  });
+  /**
+   * 获取`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`
+   */
+  _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`
+   */
+  _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 周期，如果配置，则执行变换会附带动画效果
+   */
+  _defineProperty(this, "setTransform", function (transform, duration) {
+    _this.transform = merge({}, _this.transform, transform);
+    _this.zoom.setTransform(_this.transform, 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 动画周期，如配置，则位移会附带动画效果
+   */
+  _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 动画周期，如配置，则位移会附带动画效果
+   */
+  _defineProperty(this, "nodeTranslateTo", function (config, duration) {
+    var id = config.id,
+      diff = config.diff,
+      relative = config.relative;
+    nodeTranslateTo({
+      cacheMap: _this.cacheMap,
+      diff: diff,
+      id: id,
+      relative: relative,
+      transform: _this.transform,
+      viewport: _this.viewport,
+      zoom: _this.zoom
+    }, duration);
+  });
+  /**
+   * 获取位移缩放信息
+   */
+  _defineProperty(this, "getTransform", function () {
+    return _objectSpread({}, _this.transform);
+  });
+  /**
+   * 设置锚点节点
+   * @param id 锚定节点id(如不设定，则清空锚点，根节点居中，缩放比归一)
+   */
+  _defineProperty(this, "setAnchor", function (id) {
+    _this.anchor = id;
+  });
+  /**
+   * 设置/更新数据，启动重渲染
+   * - 在重计算定位时，将保持 `anchor` 对应节点在屏幕上的相对位置不变
+   * - 如果 `anchor` 没有设定，或者找不到对应节点，则，根节点居中，缩放比重置为1
+   * @param root 根数据
+   */
+  _defineProperty(this, "setData", function (root) {
+    _this.root = root;
+    // 计算布局，定位锚点
+    _this.layout();
+    // 计算可见范围
+    _this.calcVisible();
+    // 连线
+    _this.connect();
+    // 同步层级尺寸
+    _this.syncLayoutSize();
+    // 设定数据后，通知外部可见节点
+    _this.options.callback.onNodeVisibleChange(_this.getVisibleNodes());
+  });
+  /**
+   * 刷新
+   */
+  _defineProperty(this, "refresh", function () {
+    if (_this.root) {
+      _this.setData(_this.root);
+    }
+  });
+  /**
+   * 渲染链接到某个`container`下
+   * @param container 容器
+   */
+  _defineProperty(this, "connectTo", function (container) {
+    Render.connect({
+      cacheMap: _this.cacheMap,
+      container: container,
+      options: _this.options,
+      root: _this.root
+    });
+  });
+  /**
+   * 同步渲染层尺寸到 container 中
+   */
+  _defineProperty(this, "syncLayoutSize", function () {
+    var _this$cacheMap$get5, _this$root2;
+    var layoutSize = ((_this$cacheMap$get5 = _this.cacheMap.get(((_this$root2 = _this.root) === null || _this$root2 === void 0 ? void 0 : _this$root2.node.id) || '')) === null || _this$cacheMap$get5 === void 0 ? void 0 : _this$cacheMap$get5.layoutSize) || {
+      height: 0,
+      width: 0
+    };
+    _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 设置完备
+   */
+  _defineProperty(this, "layout", function () {
+    Render.layout({
+      anchor: _this.anchor,
+      cacheMap: _this.cacheMap,
+      container: _this.container,
+      options: _this.options,
+      root: _this.root,
+      transform: _this.transform,
+      viewport: _this.viewport,
+      zoom: _this.zoom
+    });
+  });
+  /**
+   * 计算各节点可见性，以及链接可见性
+   */
+  _defineProperty(this, "calcVisible", function () {
+    return Render.calcVisible({
+      cacheMap: _this.cacheMap,
+      container: _this.container,
+      options: _this.options,
+      root: _this.root,
+      transform: _this.transform,
+      viewport: _this.viewport,
+      zoom: _this.zoom
+    });
+  });
+  this.viewport = viewport;
+  this.container = _container;
+  this.options = WithDefault.options(_options);
+  this.zoom = new Zoom(viewport);
+  this.syncZoomExtentOptions();
+  this.bindEventListener();
+});

package/dist/components/MindGraph/core/graphic/node-translate-to.d.ts

@@ -0,0 +1,11 @@
+import { Mind } from '../index';
+import { Zoom } from './zoom';
+export declare const nodeTranslateTo: (context: {
+    id: string;
+    cacheMap: Mind.CacheMap;
+    diff: Mind.Coordinate;
+    relative: Mind.Relative;
+    viewport: HTMLElement;
+    transform: Mind.Transform;
+    zoom: Zoom;
+}, duration?: number) => void;

package/dist/components/MindGraph/core/graphic/node-translate-to.js

@@ -0,0 +1,55 @@
+import { Helper } from "../helper";
+import { Mind } from "../index";
+export var nodeTranslateTo = function nodeTranslateTo(context, duration) {
+  var id = context.id,
+    cacheMap = context.cacheMap,
+    diff = context.diff,
+    relative = context.relative,
+    viewport = context.viewport,
+    transform = context.transform,
+    zoom = context.zoom;
+  var cache = cacheMap.get(id);
+  if (!cache) {
+    throw Helper.error('id match is not exist or folded');
+  } else {
+    var viewportSize = {
+      height: viewport.clientHeight,
+      width: viewport.clientWidth
+    };
+    var relativeCoordinate = {
+      x: 0,
+      y: 0
+    };
+    var nodeToScreenCoordinate = {
+      x: cache.rect.x * transform.scale,
+      y: cache.rect.y * transform.scale
+    };
+    switch (relative.x) {
+      case Mind.RelativeX.left:
+        relativeCoordinate.x = 0;
+        break;
+      case Mind.RelativeX.middle:
+        relativeCoordinate.x = viewportSize.width / 2;
+        break;
+      case Mind.RelativeX.right:
+        relativeCoordinate.x = viewportSize.width;
+        break;
+    }
+    switch (relative.y) {
+      case Mind.RelativeY.top:
+        relativeCoordinate.y = 0;
+        break;
+      case Mind.RelativeY.middle:
+        relativeCoordinate.y = viewportSize.height / 2;
+        break;
+      case Mind.RelativeY.bottom:
+        relativeCoordinate.y = viewportSize.height;
+        break;
+    }
+    zoom.setTransform({
+      scale: transform.scale,
+      x: relativeCoordinate.x - nodeToScreenCoordinate.x + diff.x,
+      y: relativeCoordinate.y - nodeToScreenCoordinate.y + diff.y
+    }, duration);
+  }
+};

package/dist/components/MindGraph/core/graphic/zoom.d.ts

@@ -0,0 +1,17 @@
+import { Mind } from '../index';
+export declare class Zoom {
+    private viewport;
+    private controller;
+    private callback?;
+    private event?;
+    constructor(viewport: HTMLElement);
+    bind: (callback: (transform: Mind.Transform) => void, event: Mind.ZoomEvent) => void;
+    syncZoomExtent: (size: Mind.Size) => void;
+    syncZoomExtentOptions: (context: {
+        options: Required<Mind.Options>;
+    }) => void;
+    scale: (scale: number, point?: Mind.Coordinate, duration?: number) => void;
+    translate: (translate: Mind.Coordinate, duration?: number) => void;
+    setTransform: (transform: Mind.Transform, duration?: number) => void;
+    destroy: () => void;
+}

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

@@ -0,0 +1,90 @@
+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); }
+// @ts-nocheck
+
+import * as D3 from 'd3';
+export var Zoom = /*#__PURE__*/_createClass(function Zoom(viewport) {
+  var _this = this;
+  _classCallCheck(this, Zoom);
+  _defineProperty(this, "viewport", void 0);
+  _defineProperty(this, "controller", D3.zoom());
+  _defineProperty(this, "callback", void 0);
+  _defineProperty(this, "event", void 0);
+  _defineProperty(this, "bind", function (callback, event) {
+    var start = event.start,
+      zoom = event.zoom,
+      end = event.end;
+    _this.callback = callback;
+    _this.event = event;
+    D3.select(_this.viewport).call(_this.controller.on('zoom', function (e) {
+      var transform = {
+        scale: e.transform.k,
+        x: e.transform.x,
+        y: e.transform.y
+      };
+      callback(transform);
+      zoom && zoom(e.sourceEvent);
+    }).on('start', function (e) {
+      return start && start(e.sourceEvent);
+    }).on('end', function (e) {
+      return end && end(e.sourceEvent);
+    })).call(_this.controller.transform, D3.zoomIdentity);
+  });
+  _defineProperty(this, "syncZoomExtent", function (size) {
+    _this.controller.extent([[0, 0], [size.width, size.height]]);
+  });
+  _defineProperty(this, "syncZoomExtentOptions", function (context) {
+    var zoomExtent = context.options.zoomExtent;
+    if (zoomExtent.translate) {
+      _this.controller.translateExtent(zoomExtent.translate.map(function (item) {
+        return [item.x, item.y];
+      }));
+    } else {
+      _this.controller.translateExtent([[-Infinity, -Infinity], [Infinity, Infinity]]);
+    }
+    if (zoomExtent.scale) {
+      _this.controller.scaleExtent(zoomExtent.scale);
+    } else {
+      _this.controller.scaleExtent([0.5, 2]);
+    }
+  });
+  _defineProperty(this, "scale", function (scale, point) {
+    var duration = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+    if (duration) {
+      D3.select(_this.viewport).transition().duration(duration).call(_this.controller.scaleTo, scale, point && [point.x, point.y]);
+    } else {
+      D3.select(_this.viewport).call(_this.controller.scaleTo, scale, point && [point.x, point.y]);
+    }
+  });
+  _defineProperty(this, "translate", function (translate) {
+    var duration = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    if (duration) {
+      D3.select(_this.viewport).transition().duration(duration).call(_this.controller.translateBy, translate.x, translate.y);
+    } else {
+      D3.select(_this.viewport).call(_this.controller.translateBy, translate.x, translate.y);
+    }
+  });
+  _defineProperty(this, "setTransform", function (transform) {
+    var duration = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    if (duration) {
+      D3.select(_this.viewport).transition().duration(duration).call(_this.controller.transform, new D3.ZoomTransform(transform.scale, transform.x, transform.y));
+    } else {
+      D3.select(_this.viewport).call(_this.controller.transform, new D3.ZoomTransform(transform.scale, transform.x, transform.y));
+    }
+  });
+  _defineProperty(this, "destroy", function () {
+    D3.select(_this.viewport).on('.zoom', null).on('.start', null).on('.end', null);
+  });
+  this.viewport = viewport;
+  this.controller.filter(function (event) {
+    // 修改默认，手势
+    // 右键移动，ctrl+滚轮 缩放
+    event.preventDefault();
+    return event.button === 0 && event.type !== 'dblclick' || event.ctrlKey && event.type === 'wheel';
+  });
+});

package/dist/components/MindGraph/core/helper/breadth-first-walk-tree.d.ts

@@ -0,0 +1,5 @@
+import { Mind } from '../index';
+export declare const breadthFirstWalkTree: (node: Mind.Node, callback: {
+    before: (node: Mind.Node) => boolean;
+    after: (rank: Mind.Node[]) => void;
+}) => void;

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

@@ -0,0 +1,21 @@
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+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; }
+export var breadthFirstWalkTree = function breadthFirstWalkTree(node, callback) {
+  var recursion = function recursion(rank) {
+    var nextLevel = [];
+    rank.forEach(function (item) {
+      if (callback.before(item)) {
+        nextLevel.push.apply(nextLevel, _toConsumableArray(item.children || []));
+      }
+    });
+    if (nextLevel.length) {
+      recursion(nextLevel);
+    }
+    callback.after(rank);
+  };
+  recursion([node]);
+};

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

@@ -0,0 +1,10 @@
+import { Mind } from '../index';
+/**
+ * 深度优先遍历
+ * @param root 根节点
+ * @param callback before:递归之前(返回 true 代表继续搜索子代，false代表终止),after:子代递归完成返回
+ */
+export declare const depthFirstWalkTree: (root: Mind.Node, callback: {
+    before: (node: Mind.Node, parent?: Mind.Node) => boolean;
+    after: (node: Mind.Node, parent?: Mind.Node) => void;
+}) => void;

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

@@ -0,0 +1,17 @@
+/**
+ * 深度优先遍历
+ * @param root 根节点
+ * @param callback before:递归之前(返回 true 代表继续搜索子代，false代表终止),after:子代递归完成返回
+ */
+export var depthFirstWalkTree = function depthFirstWalkTree(root, callback) {
+  var recursion = function recursion(now, parent) {
+    if (callback.before(now, parent)) {
+      ;
+      (now.children || []).forEach(function (n) {
+        return recursion(n, now);
+      });
+    }
+    callback.after(now, parent);
+  };
+  recursion(root, undefined);
+};

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

@@ -0,0 +1,6 @@
+import { Mind } from '../index';
+/**
+ * 获取某个节点的所有后代
+ * @param node 节点
+ */
+export declare const descendant: (node: Mind.Node) => Mind.Node[];