ebaoferc 0.0.1 → 0.0.2-beta.1

package/dist/{FlexRowCol → components/FlexRowCol}/index.js

@@ -9,7 +9,7 @@ function _objectWithoutProperties(source, excluded) { if (source == null) return
 function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
 import { useSize } from 'ahooks';
 import { Col, Row } from 'antd';
-import React, { Children, isValidElement, useRef } from 'react';
+import { Children, isValidElement, useRef } from 'react';
 import { jsx as _jsx } from "react/jsx-runtime";
 export var Gutter = [24, 0];
 export default function (props) {

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

@@ -0,0 +1,6 @@
+import { Mind } from './index';
+export declare const WithDefault: {
+    cache: (data?: Mind.NodeCache | undefined) => Required<Mind.NodeCache>;
+    options: (data?: Mind.Options | undefined) => Required<Mind.Options>;
+    transform: (data?: Mind.Transform | undefined) => Required<Mind.Transform>;
+};

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

@@ -0,0 +1,81 @@
+import { merge } from 'lodash';
+import { Mind } from "./index";
+
+// 函数式动态生成默认值，防止 value 为对象时的重复引用
+
+var generateOptions = function generateOptions() {
+  return {
+    callback: {
+      onNodeVisibleChange: function onNodeVisibleChange(_n) {},
+      onTransformChange: function onTransformChange(_t) {}
+    },
+    childAlignMode: Mind.ChildAlignMode.structured,
+    direction: Mind.Direction.x,
+    event: {
+      onViewportContextMenu: function onViewportContextMenu(_e) {},
+      onZoomEventTrigger: {
+        end: function end(_e) {},
+        start: function start(_e) {},
+        zoom: function zoom(_e) {}
+      }
+    },
+    lineStyle: Mind.LinkStyle.bezier,
+    nodeSeparate: 50,
+    rankSeparate: 50,
+    viewportPreloadPadding: 0,
+    zoomExtent: {},
+    disableLinesTailor: false
+  };
+};
+var generateCache = function generateCache() {
+  return {
+    line: {
+      source: {
+        x: 0,
+        y: 0
+      },
+      target: {
+        x: 0,
+        y: 0
+      }
+    },
+    node: {},
+    orientation: Mind.Orientation.root,
+    processCache: {},
+    rect: {
+      height: 0,
+      width: 0,
+      x: 0,
+      y: 0
+    },
+    visible: {
+      lineAttachParent: true,
+      node: true
+    }
+  };
+};
+var generateTransform = function generateTransform() {
+  return {
+    scale: 1,
+    x: 0,
+    y: 0
+  };
+};
+var withDefaultBuilder = function withDefaultBuilder(defaultData) {
+  return /* eslint-disable */(
+    function (data) {
+      if (data) {
+        return merge(defaultData(), data);
+      } else {
+        return defaultData();
+      }
+    }
+  );
+};
+/* eslint-enable */
+
+export var WithDefault = {
+  cache: withDefaultBuilder(generateCache),
+  options: withDefaultBuilder(generateOptions),
+  transform: withDefaultBuilder(generateTransform)
+};

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

@@ -0,0 +1,42 @@
+import { Mind } from '../index';
+export declare class Drag {
+    private readonly options;
+    private readonly cacheMap;
+    private readonly root;
+    private readonly dragNode;
+    private readonly ignoreNodes;
+    private temporaryLine;
+    private readonly container;
+    private readonly draggableLayout;
+    constructor(context: {
+        options: Required<Mind.Options>;
+        cacheMap: Mind.CacheMap;
+        root: Mind.Root;
+        dragNode: Mind.Node;
+        container: HTMLElement;
+    });
+    /**
+     * 获取拖动节点插入到关联节点子代的下标
+     * @param attachedNodeChildren 关联节点的子代
+     * @param dropPosition 拖动节点镜像中心位置
+     * @param dragNode 拖动节点
+     * @param attachedNode 被关联的节点
+     * @return 期望插入位置
+     */
+    calcDropIndex: (attachedNodeChildren: Mind.Node[] | undefined, dropPosition: Mind.Coordinate, dragNode: Mind.Node, attachedNode: Mind.Node) => number;
+    /**
+     * 拖动操作
+     * - 根节点不可拖拽
+     * @param position 拖动节点镜像中心位置
+     * @param canBeAttachedNodes 需要搜索的可关联节点
+     * @return 链接关联信息
+     */
+    drag: (position: Mind.Coordinate, canBeAttachedNodes: Mind.Node[]) => {
+        attach: Mind.Node;
+        orientation: Mind.Orientation;
+    } | undefined;
+    /**
+     * 通知控制器拖动操作结束
+     */
+    end: () => void;
+}

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

@@ -0,0 +1,120 @@
+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 _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; }
+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 { Helper } from "../helper";
+import { Process } from "../process";
+import { DraggableLayout } from "../process/layout/type";
+import { TemporaryLine } from "../render/connect/temporary-line";
+export var Drag = /*#__PURE__*/_createClass(function Drag(context) {
+  var _this = this;
+  _classCallCheck(this, Drag);
+  _defineProperty(this, "options", void 0);
+  _defineProperty(this, "cacheMap", void 0);
+  _defineProperty(this, "root", void 0);
+  _defineProperty(this, "dragNode", void 0);
+  _defineProperty(this, "ignoreNodes", void 0);
+  _defineProperty(this, "temporaryLine", void 0);
+  _defineProperty(this, "container", void 0);
+  _defineProperty(this, "draggableLayout", void 0);
+  /**
+   * 获取拖动节点插入到关联节点子代的下标
+   * @param attachedNodeChildren 关联节点的子代
+   * @param dropPosition 拖动节点镜像中心位置
+   * @param dragNode 拖动节点
+   * @param attachedNode 被关联的节点
+   * @return 期望插入位置
+   */
+  _defineProperty(this, "calcDropIndex", function (attachedNodeChildren, dropPosition, dragNode, attachedNode) {
+    return _this.draggableLayout.calcDropIndex({
+      attachedNode: attachedNode,
+      attachedNodeChildren: attachedNodeChildren,
+      cacheMap: _this.cacheMap,
+      dragNode: dragNode,
+      dropPosition: dropPosition,
+      options: _this.options,
+      root: _this.root
+    });
+  });
+  /**
+   * 拖动操作
+   * - 根节点不可拖拽
+   * @param position 拖动节点镜像中心位置
+   * @param canBeAttachedNodes 需要搜索的可关联节点
+   * @return 链接关联信息
+   */
+  _defineProperty(this, "drag", function (position, canBeAttachedNodes) {
+    var cache = _this.cacheMap.get(_this.dragNode.id);
+
+    // 根节点不可拖拽
+    if (!cache || cache.node.id === _this.root.node.id) {
+      return undefined;
+    }
+    var dragAttach = _this.draggableLayout.calcDragAttach({
+      cacheMap: _this.cacheMap,
+      canBeAttachedNodes: canBeAttachedNodes,
+      draggingRect: _objectSpread(_objectSpread({}, position), {}, {
+        height: cache.rect.height,
+        width: cache.rect.width
+      }),
+      ignoreNodes: _this.ignoreNodes,
+      options: _this.options,
+      root: _this.root
+    });
+
+    // 数据成功获取
+    if (dragAttach) {
+      _this.temporaryLine.render({
+        source: dragAttach.link.source,
+        target: dragAttach.link.target
+      });
+      return {
+        attach: dragAttach.node,
+        orientation: dragAttach.orientation
+      };
+    } else {
+      _this.temporaryLine.render();
+      return undefined;
+    }
+  });
+  /**
+   * 通知控制器拖动操作结束
+   */
+  _defineProperty(this, "end", function () {
+    _this.temporaryLine.destroy();
+  });
+  var options = context.options,
+    root = context.root,
+    _dragNode = context.dragNode,
+    cacheMap = context.cacheMap,
+    container = context.container;
+  this.options = options;
+  this.root = root;
+  this.dragNode = _dragNode;
+  this.cacheMap = cacheMap;
+  this.container = container;
+  this.draggableLayout = Process.getLayoutProcess(options);
+  // 检查当前使用的算法是否支持拖拽操作，如不支持，则报错
+  if (!DraggableLayout.isValidExtendsClass(this.draggableLayout)) {
+    if (options.layoutProcess) {
+      throw Helper.error("The custom layoutProcess is not support drag action, it should extends DraggableLayout");
+    } else {
+      throw Helper.error("The childAlignMode=\"".concat(options.childAlignMode, "\" match layout process ").concat(this.draggableLayout.name, " is not support drag action"));
+    }
+  }
+  // 当前节点以及其后代，全部忽略计算
+  this.ignoreNodes = [this.dragNode].concat(_toConsumableArray(Helper.descendant(this.dragNode)));
+  // 创建临时线
+  this.temporaryLine = new TemporaryLine(this.container, this.cacheMap, this.options);
+});

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

@@ -0,0 +1,181 @@
+import { Mind } from '../index';
+import { Drag } from './drag';
+export declare class Graphic {
+    /**
+     * 节点相关信息缓存，树形结构拍平
+     */
+    private cacheMap;
+    private options;
+    private readonly container;
+    private readonly viewport;
+    private transform;
+    private root?;
+    private anchor?;
+    private resizeObserver;
+    private unbindCache;
+    private readonly zoom;
+    /**
+     * 脑图管理器
+     * - `viewport`用作判断可视区域
+     * - svg连线将会自动注入到`container`中
+     * - transform 相关信息将会自动注入到`container`中
+     * @param viewport 视窗
+     * @param container 容器
+     * @param options 配置参数
+     */
+    constructor(viewport: HTMLElement, container: HTMLElement, options?: Mind.Options);
+    /**
+     * 同步 options 中的 zoom extent
+     */
+    private syncZoomExtentOptions;
+    /**
+     * 获取当前可见的节点
+     */
+    private getVisibleNodes;
+    /**
+     * 获取节点定位锚点（左上角）位置，可在节点绘制的时候确定其位置
+     * - 推荐所有节点使用`position:absolute;left:0;top:0;`并且配合`transform`来定位，避免出现绘制异常
+     * @param id 节点对应id
+     */
+    getNodeAnchorCoordinate: (id: string) => Mind.Coordinate | undefined;
+    private bindEventListener;
+    private onTransform;
+    /**
+     * - 计算节点可见是否改变，如改变，则通知外部
+     * - 重渲染连线，销毁不必要的连线
+     */
+    private refreshVisible;
+    private throttleRefreshVisible;
+    /**
+     * 视窗尺寸变化
+     * @private
+     */
+    private onViewportResize;
+    /**
+     * 注销事件绑定
+     * - 请在销毁组件之前调用
+     */
+    unbind: () => void;
+    /**
+     * 判断节点是否可视
+     * @param id 节点对应id
+     */
+    judgeNodeVisible: (id: string) => boolean;
+    /**
+     * 设定 `options`
+     * - 函数不会自动执行重渲染，如果改变的`options`需要重新计算布局等操作，推荐使用 `setData` 驱动数据重渲染
+     * @param options 设定选项
+     * @param isMerge 是否与之前的`options`做合并操作
+     */
+    setOptions: (options?: Mind.Options, isMerge?: boolean) => void;
+    /**
+     * 生成拖动控制器
+     * - 根节点不可拖拽
+     * - 当前暂时只有`Mind.ChildAlignMode.structured`布局算法支持拖拽功能
+     * @param drag 拖动节点node对象或id
+     * @return
+     * - 当root（没有调用`setData`）不存在时，或者`drag`为根节点时，返回`undefined`
+     * - 正常情况返回 `Drag` 类对象
+     */
+    dragControllerBuilder: (drag: Mind.Node | string) => Drag | undefined;
+    /**
+     * 获取渲染层尺寸
+     */
+    getLayoutSize: () => Mind.Size | undefined;
+    /**
+     * 获取`id`对应节点
+     * @param id 节点`id`
+     */
+    getNode: (id: string) => Mind.Node | undefined;
+    /**
+     * 获取`id`对应节点父级
+     * @param id 节点`id`
+     */
+    getParent: (id: string) => Mind.Node | undefined;
+    /**
+     * 获取`id`对应节点渲染方位
+     * @param id 节点`id`
+     */
+    getNodeOrientation: (id: string) => Mind.Orientation | undefined;
+    /**
+     * 主动设置位移缩放
+     * - 会与之前的`transform`做深度合并
+     * - 请注意：`setTransform` 之后 `onTransformChange` 事件依旧会触发
+     * - 此方法不受 `zoomExtent.translate`、`zoomExtent.scale` 限制
+     * @param transform 位移缩放数据
+     * @param duration 周期，如果配置，则执行变换会附带动画效果
+     */
+    setTransform: (transform: Partial<Mind.Transform>, duration?: number) => void;
+    /**
+     * 设定位移
+     * - 此方法受到 `zoomExtent.translate` 限制
+     * @param translate 位移差(屏幕尺度)
+     * @param duration 周期，如果配置，则执行变换会附带动画效果
+     */
+    translate: (translate: Mind.Coordinate, duration?: number) => void;
+    /**
+     * 设定缩放
+     * - 此方法受到 `zoomExtent.translate` 限制
+     * - 此方法受到 `zoomExtent.scale` 限制
+     * @param scale 缩放比
+     * @param point 缩放相对点（如不配置或为`undefined`，则默认相对于`viewport`中心缩放）
+     * @param duration 动画周期，如配置，则位移会附带动画效果
+     */
+    scale: (scale: number, point?: Mind.Coordinate, duration?: number) => void;
+    /**
+     * 将某一个节点中心从某个相对位置做位移（其尺度为屏幕尺度）操作
+     * - 此方法不受 `zoomExtent.translate` 限制
+     * @param config 配置参数
+     * @param config.id 节点id
+     * @param config.diff 位移差
+     * @param config.relative 相对位置
+     * @param duration 动画周期，如配置，则位移会附带动画效果
+     */
+    nodeTranslateTo: (config: {
+        id: string;
+        diff: Mind.Coordinate;
+        relative: Mind.Relative;
+    }, duration?: number) => void;
+    /**
+     * 获取位移缩放信息
+     */
+    getTransform: () => Mind.Transform;
+    /**
+     * 设置锚点节点
+     * @param id 锚定节点id(如不设定，则清空锚点，根节点居中，缩放比归一)
+     */
+    setAnchor: (id?: string) => void;
+    /**
+     * 设置/更新数据，启动重渲染
+     * - 在重计算定位时，将保持 `anchor` 对应节点在屏幕上的相对位置不变
+     * - 如果 `anchor` 没有设定，或者找不到对应节点，则，根节点居中，缩放比重置为1
+     * @param root 根数据
+     */
+    setData: (root: Mind.Root) => void;
+    /**
+     * 刷新
+     */
+    refresh: () => void;
+    /**
+     * 渲染链接到某个`container`下
+     * @param container 容器
+     */
+    connectTo: (container: HTMLElement) => void;
+    /**
+     * 同步渲染层尺寸到 container 中
+     */
+    private syncLayoutSize;
+    /**
+     * 链接各个节点
+     */
+    private connect;
+    /**
+     * 计算脑图布局
+     * - 请保证调用之前 data 已经通过 setData 设置完备
+     */
+    private layout;
+    /**
+     * 计算各节点可见性，以及链接可见性
+     */
+    private calcVisible;
+}