ebaoferc 0.0.1 → 0.0.2-beta.1

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

@@ -0,0 +1,394 @@
+import { Graphic as GraphicClass } from './graphic';
+import { Drag as DragClass } from './graphic/drag';
+import { Process as ProcessModule } from './process';
+import { DraggableLayout as DraggableLayoutClass } from './process/layout/type';
+export declare namespace Mind {
+    type ValueOf<T> = T[keyof T];
+    export interface Size {
+        width: number;
+        height: number;
+    }
+    export interface Coordinate {
+        x: number;
+        y: number;
+    }
+    export type CacheMap = Map<string, Mind.NodeCache>;
+    export const ChildAlignMode: {
+        /**
+         * 子代对齐模式
+         */
+        readonly descendantCenter: "descendant-center";
+        /**
+         * 直系子代节点中心对齐
+         */
+        readonly heirCenter: "heir-center";
+        /**
+         * 结构化规整模式
+         */
+        readonly structured: "structured";
+    };
+    export type ChildAlignMode = ValueOf<typeof ChildAlignMode>;
+    export interface Root {
+        /**
+         * 根节点数据
+         */
+        node: Omit<Node, 'children'>;
+        /**
+         * 正向区域节点
+         */
+        positive?: Node[];
+        /**
+         * 负向区域节点
+         */
+        negative?: Node[];
+    }
+    export const Orientation: {
+        /**
+         * 处于正向区域
+         */
+        readonly negative: "negative";
+        /**
+         * 处于负向区域
+         */
+        readonly positive: "positive";
+        /**
+         * 根节点
+         */
+        readonly root: "root";
+    };
+    export type Orientation = ValueOf<typeof Orientation>;
+    export const Direction: {
+        /**
+         * x轴水平方向渲染
+         */
+        readonly x: "x";
+        /**
+         * y轴垂直方向渲染
+         */
+        readonly y: "y";
+    };
+    export type Direction = ValueOf<typeof Direction>;
+    export interface Visible {
+        /**
+         * 节点本身是否可见
+         */
+        node: boolean;
+        /**
+         * 与父级之间的连线
+         */
+        lineAttachParent: boolean;
+    }
+    export interface Transform {
+        x: number;
+        y: number;
+        scale: number;
+    }
+    export const LinkStyle: {
+        /**
+         * 贝塞尔曲线
+         */
+        readonly bezier: "bezier";
+        /**
+         * 线性
+         * - 线性只有在 ChildAlignMode.structured 风格下表现最佳
+         */
+        readonly line: "line";
+    };
+    export type LinkStyle = ValueOf<typeof LinkStyle>;
+    export interface PathData extends Line {
+        /**
+         * 节点自身数据
+         */
+        node: Mind.Node;
+    }
+    export interface Range<T> {
+        min: T;
+        max: T;
+    }
+    export interface PathRenderContext extends PathData {
+        /**
+         * 设定
+         */
+        options: Required<Options>;
+        /**
+         * 缓存地图
+         */
+        cacheMap: CacheMap;
+    }
+    /**
+     * 拖动关联信息
+     */
+    export interface DragAttach {
+        /**
+         * 链接
+         */
+        link: {
+            source: Mind.Coordinate;
+            target: Mind.Coordinate;
+        };
+        /**
+         * 关联节点
+         */
+        node: Mind.Node;
+        /**
+         * 拖动节点关联到目标节点的区域
+         */
+        orientation: Mind.Orientation;
+    }
+    export interface NodeCache {
+        /**
+         * 节点方位
+         */
+        orientation: Orientation;
+        /**
+         * 节点数据
+         */
+        node: Node;
+        /**
+         * 节点所属矩形大小以及位置
+         */
+        rect: Size & Coordinate;
+        /**
+         * 是否可见
+         */
+        visible: Visible;
+        /**
+         * 父级节点
+         */
+        parent?: Node;
+        /**
+         * 处理器在处理时的缓存数据
+         */
+        processCache: any;
+        /**
+         * 连线相关信息
+         */
+        line: Line;
+        /**
+         * 整体布局尺寸
+         * - 只有根节点保存此数据
+         */
+        layoutSize?: Size;
+    }
+    export interface Event {
+        /**
+         * 视窗上下文菜单事件
+         * - 组件禁用了在视窗上的右键菜单
+         * @param e
+         */
+        onViewportContextMenu?: (e: MouseEvent) => void;
+        /**
+         * zoom 事件触发器
+         */
+        onZoomEventTrigger?: ZoomEvent;
+    }
+    export interface Callback {
+        /**
+         * 转换发生改变，通知外部
+         * @param transform
+         */
+        onTransformChange?: (transform: Transform) => void;
+        /**
+         * 可见节点发生了改变
+         * - 每一次 `setData` 后都必定会调用此事件
+         * @param nodes 可见节点数组(节点都是对`setData`中节点数据的引用，请注意根节点设置`children`无效)
+         */
+        onNodeVisibleChange?: (nodes: Mind.Node[]) => void;
+    }
+    export interface Line {
+        /**
+         * 链接线起点（节点父级）
+         */
+        source: Coordinate;
+        /**
+         * 连接线终点（节点自身）
+         */
+        target: Coordinate;
+    }
+    export interface Node {
+        /**
+         * 全局唯一 id
+         */
+        id: string;
+        /**
+         * 子代
+         */
+        children?: Node[];
+        /**
+         * 是否折叠子代
+         * - 根节点为数组，[negative,positive]
+         * - 普通节点直接代表是否折叠子代
+         * @default false | [false,false]
+         */
+        fold?: boolean | boolean[];
+        /**
+         * 附带数据
+         * - 请将节点附带的数据全部存储到此处
+         */
+        attachData?: any;
+        /**
+         * 获取当前节点尺寸
+         */
+        sizeof: () => Size;
+    }
+    export type PathRender = (context: PathRenderContext) => string;
+    export const RelativeX: {
+        readonly left: "left";
+        readonly middle: "middle";
+        readonly right: "right";
+    };
+    export type RelativeX = ValueOf<typeof RelativeX>;
+    export const RelativeY: {
+        readonly bottom: "bottom";
+        readonly middle: "middle";
+        readonly top: "top";
+    };
+    export type RelativeY = ValueOf<typeof RelativeY>;
+    export interface Relative {
+        x: RelativeX;
+        y: RelativeY;
+    }
+    export interface ZoomExtent {
+        /**
+         * 位移边界
+         * - 其是可视区域（viewport）在图形所在世界的边界坐标
+         * - 计算时，可以简单的将 viewport 视作可移动的部分，图形保持位置不变（注意scale带来的影响，需要将viewport转换到图形所在世界坐标系,EM: viewport.width/scale)）
+         * default [[x: -∞, y: -∞], [x: +∞, y :+∞]]
+         */
+        translate?: [Coordinate, Coordinate];
+        /**
+         * 缩放边界
+         * default [0, ∞]
+         */
+        scale?: [number, number];
+    }
+    export interface Options {
+        /**
+         * 禁止连接线裁剪渲染
+         * @default false
+         */
+        disableLinesTailor?: boolean;
+        /**
+         * 渲染方向
+         * - positive 在 x 模式下渲染在右侧，y 模式下渲染在上侧
+         * - negative 在 x 模式下渲染在左侧，y 模式下渲染在下侧
+         * default 'x' 水平方向
+         */
+        direction?: Direction;
+        /**
+         * 节点间距
+         * @default 50
+         */
+        nodeSeparate?: number;
+        /**
+         * 每一级的距离
+         * @default 50
+         */
+        rankSeparate?: number;
+        /**
+         * 子代对齐模式(布局模式)
+         * @default 'structured'
+         */
+        childAlignMode?: ChildAlignMode;
+        /**
+         * 视窗四周预加载尺寸
+         * @default 0
+         */
+        viewportPreloadPadding?: number;
+        /**
+         * 回调
+         */
+        callback?: Callback;
+        /**
+         * 事件
+         */
+        event?: Event;
+        /**
+         * 连线样式风格
+         * @default 'bezier'
+         */
+        lineStyle?: LinkStyle;
+        /**
+         * 自定义path渲染路径
+         * - 优先级高于 `lineStyle`
+         * @param data
+         * @return 返回字符串将作为 path d 属性
+         */
+        pathRender?: PathRender | undefined;
+        /**
+         * 自定义布局处理器
+         * - 优先级高于 childAlignMode 选择的布局方式
+         */
+        layoutProcess?: {
+            new (): Process.Lifecycle;
+        };
+        /**
+         * 缩放尺度控制
+         */
+        zoomExtent?: ZoomExtent;
+    }
+    /**
+     * 位移/缩放事件函数
+     * @param event the underlying input event, such as mousemove or touchmove
+     */
+    export type ZoomEventFunc = (event: any) => void;
+    export interface ZoomEvent {
+        /**
+         * 缩放/拖动开始事件
+         */
+        start?: ZoomEventFunc;
+        /**
+         * 缩放/拖动中事件
+         */
+        zoom?: ZoomEventFunc;
+        /**
+         * 缩放/拖动结束
+         */
+        end?: ZoomEventFunc;
+    }
+    export namespace Process {
+        type Lifecycle = ProcessModule.Lifecycle;
+        type StartContext = ProcessModule.StartContext;
+        type EveryContext = ProcessModule.EveryContext;
+    }
+    export type Graphic = GraphicClass;
+    export const Graphic: typeof GraphicClass;
+    export type Drag = DragClass;
+    export const Drag: typeof DragClass;
+    export type DraggableLayout = DraggableLayoutClass;
+    export const DraggableLayout: typeof DraggableLayoutClass;
+    export const _Helper: {
+        breadthFirstWalkTree: (node: Node, callback: {
+            before: (node: Node) => boolean;
+            after: (rank: Node[]) => void;
+        }) => void; /**
+         * 直系子代节点中心对齐
+         */
+        depthFirstWalkTree: (root: Node, callback: {
+            before: (node: Node, parent?: Node | undefined) => boolean;
+            after: (node: Node, parent?: Node | undefined) => void;
+        }) => void;
+        descendant: (node: Node) => Node[];
+        error: (message: string) => Error;
+        getLayoutCalcChildren: (node: Node, rootId: string, getRootHeirOrientation: ProcessModule.getRootHeirOrientationFunc) => Node[];
+        getSvgPathId: (id: string) => string;
+        judgeIfAllChildFold: (node: Node, rootId: string) => boolean;
+        judgeIfHeirAndFold: (node: Node, parent: Node | undefined, root: Root, getRootHeirOrientation: ProcessModule.getRootHeirOrientationFunc) => boolean;
+        judgeIfVisualLeaf: (node: Node, children?: Node[] | undefined) => boolean | boolean[] | undefined;
+        rootToNodeArray: (root: Root, callback: (node: Node) => void) => Node[];
+        transformRootToWalkable: (root: Root) => {
+            getRootHeirOrientation: (id: string) => Orientation;
+            shadowNode: Node;
+        };
+        withPrefix: (message: string) => string;
+    };
+    export const _Process: typeof ProcessModule;
+    export const _WithDefault: {
+        cache: (data?: NodeCache | undefined) => Required<NodeCache>;
+        options: (data?: Options | undefined) => Required<Options>;
+        transform: (data?: Transform | undefined) => Required<Transform>; /**
+         * y轴垂直方向渲染
+         */
+    };
+    export {};
+}

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

@@ -0,0 +1,86 @@
+/* eslint-disable @typescript-eslint/no-namespace */
+import { WithDefault } from "./default";
+import { Graphic as GraphicClass } from "./graphic";
+import { Drag as DragClass } from "./graphic/drag";
+import { Helper } from "./helper";
+import { Process as ProcessModule } from "./process";
+import { DraggableLayout as DraggableLayoutClass } from "./process/layout/type";
+export var Mind;
+(function (_Mind) {
+  var ChildAlignMode = _Mind.ChildAlignMode = {
+    /**
+     * 子代对齐模式
+     */
+    descendantCenter: 'descendant-center',
+    /**
+     * 直系子代节点中心对齐
+     */
+    heirCenter: 'heir-center',
+    /**
+     * 结构化规整模式
+     */
+    structured: 'structured'
+  };
+  var Orientation = _Mind.Orientation = {
+    /**
+     * 处于正向区域
+     */
+    negative: 'negative',
+    /**
+     * 处于负向区域
+     */
+    positive: 'positive',
+    /**
+     * 根节点
+     */
+    root: 'root'
+  };
+  var Direction = _Mind.Direction = {
+    /**
+     * x轴水平方向渲染
+     */
+    x: 'x',
+    /**
+     * y轴垂直方向渲染
+     */
+    y: 'y'
+  };
+  var LinkStyle = _Mind.LinkStyle = {
+    /**
+     * 贝塞尔曲线
+     */
+    bezier: 'bezier',
+    /**
+     * 线性
+     * - 线性只有在 ChildAlignMode.structured 风格下表现最佳
+     */
+    line: 'line'
+  };
+
+  /**
+   * 拖动关联信息
+   */
+
+  var RelativeX = _Mind.RelativeX = {
+    left: 'left',
+    middle: 'middle',
+    right: 'right'
+  };
+  var RelativeY = _Mind.RelativeY = {
+    bottom: 'bottom',
+    middle: 'middle',
+    top: 'top'
+  };
+
+  /**
+   * 位移/缩放事件函数
+   * @param event the underlying input event, such as mousemove or touchmove
+   */
+
+  var Graphic = _Mind.Graphic = GraphicClass;
+  var Drag = _Mind.Drag = DragClass;
+  var DraggableLayout = _Mind.DraggableLayout = DraggableLayoutClass;
+  var _Helper = _Mind._Helper = Helper;
+  var _Process = _Mind._Process = ProcessModule;
+  var _WithDefault = _Mind._WithDefault = WithDefault;
+})(Mind || (Mind = {}));

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

@@ -0,0 +1,12 @@
+import { Process } from './index';
+export declare class Anchor implements Process.Lifecycle {
+    private preAnchorRect?;
+    private anchor?;
+    private cacheMap;
+    private transform;
+    private zoom;
+    private viewport;
+    private root;
+    start: (context: Process.StartContext) => void;
+    end: () => void;
+}

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

@@ -0,0 +1,63 @@
+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); }
+export var Anchor = /*#__PURE__*/_createClass(function Anchor() {
+  var _this = this;
+  _classCallCheck(this, Anchor);
+  _defineProperty(this, "preAnchorRect", void 0);
+  _defineProperty(this, "anchor", void 0);
+  _defineProperty(this, "cacheMap", void 0);
+  _defineProperty(this, "transform", void 0);
+  _defineProperty(this, "zoom", void 0);
+  _defineProperty(this, "viewport", void 0);
+  _defineProperty(this, "root", void 0);
+  _defineProperty(this, "start", function (context) {
+    var preCacheMap = context.preCacheMap,
+      cacheMap = context.cacheMap,
+      anchor = context.anchor,
+      transform = context.transform,
+      zoom = context.zoom,
+      viewport = context.viewport,
+      root = context.root;
+    _this.anchor = anchor;
+    _this.cacheMap = cacheMap;
+    _this.transform = transform;
+    _this.zoom = zoom;
+    _this.viewport = viewport;
+    _this.root = root;
+    if (anchor && preCacheMap.get(anchor)) {
+      _this.preAnchorRect = _objectSpread({}, preCacheMap.get(anchor).rect);
+    }
+  });
+  _defineProperty(this, "end", function () {
+    var anchorCache = _this.cacheMap.get(_this.anchor || '');
+
+    // 在经历数据改变，布局重计算之后，锚点依然存在，则，锁定锚点，保持缩放比不变
+    if (anchorCache && _this.preAnchorRect) {
+      var diff = {
+        x: (anchorCache.rect.x - _this.preAnchorRect.x) * _this.transform.scale,
+        y: (anchorCache.rect.y - _this.preAnchorRect.y) * _this.transform.scale
+      };
+      _this.zoom.setTransform({
+        scale: _this.transform.scale,
+        x: _this.transform.x - diff.x,
+        y: _this.transform.y - diff.y
+      });
+    }
+    // 没有找到任何锚点，则，根节点居中，缩放比归一
+    else {
+      var rootRect = _this.cacheMap.get(_this.root.node.id);
+      _this.zoom.setTransform({
+        scale: 1,
+        x: _this.viewport.clientWidth / 2 - rootRect.rect.x,
+        y: _this.viewport.clientHeight / 2 - rootRect.rect.y
+      });
+    }
+  });
+});

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

@@ -0,0 +1,91 @@
+import { Zoom } from '../graphic/zoom';
+import { Mind } from '../index';
+import { Anchor as AnchorProcess } from './anchor';
+import { DescendantCenterLayout as DescendantCenterLayoutProcess, HeirCenterLayout as HeirCenterLayoutProcess, StructuredLayout as StructuredLayoutProcess } from './layout';
+import { Line as LineProcess } from './line';
+import { NodeValid as NodeValidProcess } from './node-valid';
+import { Orientation as OrientationProcess } from './orientation';
+import { Size as SizeProcess } from './size';
+import { Visible as VisibleProcess } from './visible';
+export declare namespace Process {
+    type getRootHeirOrientationFunc = (id: string) => Mind.Orientation;
+    interface EveryContext {
+        /**
+         * 当前处理节点缓存信息
+         */
+        cache: Mind.NodeCache;
+    }
+    interface StartContext {
+        /**
+         * 配置项
+         */
+        options: Required<Mind.Options>;
+        /**
+         * 根数据
+         */
+        root: Mind.Root;
+        /**
+         * 获取根直系子代的方位
+         * @param id 直系子代 id
+         */
+        getRootHeirOrientation: getRootHeirOrientationFunc;
+        /**
+         * 缓存地图
+         */
+        cacheMap: Mind.CacheMap;
+        /**
+         * 上一次的缓存地图
+         */
+        preCacheMap?: Mind.CacheMap;
+        /**
+         * 可视窗口
+         */
+        viewport: HTMLElement;
+        /**
+         * 内容容器
+         */
+        container: HTMLElement;
+        /**
+         * 位移/缩放配置
+         */
+        transform: Mind.Transform;
+        /**
+         * 配置锚点
+         */
+        anchor?: string;
+        /**
+         * 位移/缩放控制器
+         */
+        zoom: Zoom;
+    }
+    interface Lifecycle<S = void, E = void, AE = void, END = void> {
+        /**
+         * 开始步骤
+         */
+        start?: (context: StartContext) => S;
+        /**
+         * 每一个节点处理（开始深度优先递归子代之前）
+         * @param context 上下文环境
+         */
+        every?: (context: EveryContext) => E;
+        /**
+         * 每一个节点处理（结束深度优先递归子代之后）
+         * @param context 上下文环境
+         */
+        afterEvery?: (context: EveryContext) => AE;
+        /**
+         * 结束处理步骤
+         */
+        end?: () => END;
+    }
+    const Size: typeof SizeProcess;
+    const HeirCenterLayout: typeof HeirCenterLayoutProcess;
+    const DescendantCenterLayout: typeof DescendantCenterLayoutProcess;
+    const StructuredLayout: typeof StructuredLayoutProcess;
+    const Visible: typeof VisibleProcess;
+    const Line: typeof LineProcess;
+    const Orientation: typeof OrientationProcess;
+    const Anchor: typeof AnchorProcess;
+    const NodeValid: typeof NodeValidProcess;
+    const getLayoutProcess: (options: Required<Mind.Options>) => (new () => Mind.Process.Lifecycle) | typeof HeirCenterLayoutProcess | typeof DescendantCenterLayoutProcess | typeof StructuredLayoutProcess;
+}

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

@@ -0,0 +1,30 @@
+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); }
+/* eslint-disable @typescript-eslint/no-namespace */
+
+import { Mind } from "../index";
+import { Anchor as AnchorProcess } from "./anchor";
+import { DescendantCenterLayout as DescendantCenterLayoutProcess, HeirCenterLayout as HeirCenterLayoutProcess, StructuredLayout as StructuredLayoutProcess } from "./layout";
+import { Line as LineProcess } from "./line";
+import { NodeValid as NodeValidProcess } from "./node-valid";
+import { Orientation as OrientationProcess } from "./orientation";
+import { Size as SizeProcess } from "./size";
+import { Visible as VisibleProcess } from "./visible";
+export var Process;
+(function (_Process) {
+  var Size = _Process.Size = SizeProcess;
+  var HeirCenterLayout = _Process.HeirCenterLayout = HeirCenterLayoutProcess;
+  var DescendantCenterLayout = _Process.DescendantCenterLayout = DescendantCenterLayoutProcess;
+  var StructuredLayout = _Process.StructuredLayout = StructuredLayoutProcess;
+  var Visible = _Process.Visible = VisibleProcess;
+  var Line = _Process.Line = LineProcess;
+  var Orientation = _Process.Orientation = OrientationProcess;
+  var Anchor = _Process.Anchor = AnchorProcess;
+  var NodeValid = _Process.NodeValid = NodeValidProcess;
+  var getLayoutProcess = _Process.getLayoutProcess = function (options) {
+    var matchMap = _defineProperty(_defineProperty(_defineProperty({}, Mind.ChildAlignMode.heirCenter, HeirCenterLayoutProcess), Mind.ChildAlignMode.descendantCenter, DescendantCenterLayoutProcess), Mind.ChildAlignMode.structured, StructuredLayoutProcess);
+    return options.layoutProcess ? options.layoutProcess : matchMap[options.childAlignMode];
+  };
+})(Process || (Process = {}));

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

@@ -0,0 +1,2 @@
+import { Mind } from '../../index';
+export declare const generateDagreGraphic: (options: Mind.Options) => any;