@relation-graph/react 3.0.0

package/types/packages/platforms/vue3/src/relation-graph/src/hooks/useGraphInstance.d.ts

@@ -0,0 +1,13 @@
+import { JsonLine, JsonNode, RelationGraphInstance, RGLineTarget } from '../../../../../../relation-graph-models/types';
+export declare function useGraphInstance<InstanceType extends RelationGraphInstance>(): InstanceType;
+export declare function useGraphInstanceGetter<InstanceType extends RelationGraphInstance>(): () => InstanceType;
+export declare function useCreatingLine(graphInstance: RelationGraphInstance): {
+    creating: boolean;
+    fromTarget?: RGLineTarget;
+    toTarget?: RGLineTarget;
+    lineJson?: JsonLine;
+};
+export declare function useCreatingNode(graphInstance: RelationGraphInstance): {
+    creating: boolean;
+    nodeJson?: JsonNode;
+};

package/types/packages/platforms/vue3/src/types-vue3.d.ts

@@ -0,0 +1,22 @@
+import { VueElement, VNode } from 'vue';
+import { RelationGraphProps, RelationGraphInstance, RGJsonData, RGRefreshCallback } from './types';
+export declare class RelationGraphComponent extends VueElement {
+    getInstance(): RelationGraphInstance;
+    setJsonData(jsonData: RGJsonData, reLayoutOrCallback?: boolean | RGRefreshCallback, callback?: (graphInstance: RelationGraphInstance) => void): any;
+    $props: RelationGraphProps;
+    $slots: {
+        default: VNode[];
+        canvasPlug: VNode[];
+        miniToolBar: VNode[];
+        miniViewPanel: VNode[];
+        nodeExpandHolder: VNode[];
+        graphPlug: VNode[];
+        svgDefs: VNode[];
+        node: VNode[];
+        line: VNode[];
+    };
+}
+export type RGProviderData = {
+    graphInstance: RelationGraphInstance;
+};
+export declare const version: string;

package/types/packages/platforms/vue3/src/types.d.ts

@@ -0,0 +1 @@
+export * from '../../../relation-graph-models/types';

package/types/packages/platforms/vue3/vite.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vite').UserConfigExport;
+export default _default;

package/types/packages/relation-graph-models/RGObjectsForExport.d.ts

@@ -0,0 +1,132 @@
+import { default as BaseLayouter } from './layouters/RGBaseLayouter';
+import { default as BidirectionalTreeLayouter } from './layouters/RGTreeLayouter';
+import { default as CenterLayouter } from './layouters/RGCenterLayouter';
+import { default as CircleLayouter } from './layouters/RGCircleLayouter';
+import { default as FixedLayouter } from './layouters/RGFixedLayouter';
+import { default as ForceLayouter } from './layouters/RGForceLayouter';
+import { default as RGFolderLayouter } from './layouters/RGFolderLayouter';
+import * as RGOptionsDataUtils from "./models/RGOptionsDataUtils";
+import * as RGLineDataUtils from "./models/RGLineDataUtils";
+import * as RGNodeDataUtils from "./models/RGNodeDataUtils";
+export declare const RGLayout: {
+    BaseLayouter: typeof BaseLayouter;
+    BidirectionalTreeLayouter: typeof BidirectionalTreeLayouter;
+    CenterLayouter: typeof CenterLayouter;
+    CircleLayouter: typeof CircleLayouter;
+    FixedLayouter: typeof FixedLayouter;
+    ForceLayouter: typeof ForceLayouter;
+    RGFolderLayouter: typeof RGFolderLayouter;
+};
+export declare const RGUtils: {
+    RGOptionsDataUtils: typeof RGOptionsDataUtils;
+    RGLineDataUtils: typeof RGLineDataUtils;
+    RGNodeDataUtils: typeof RGNodeDataUtils;
+    RGGraphMath: {
+        getRectPoint(from_x: number, from_y: number, to_x: number, to_y: number, f_W: number, f_H: number, t_W: number, t_H: number, isReverse?: boolean, totalLines?: number, currentIndex?: number, lineDistance?: number, isEndPoint?: boolean): {
+            x: number;
+            y: number;
+        };
+        getRectPointBasic(x1: number, y1: number, x2: number, y2: number, n1w: number, n1h: number, n2w: number, n2h: number): {
+            x: number;
+            y: number;
+            _case: string;
+        };
+        getRectJoinPoint(params: import('./utils/RGGraphMath').CreateJunctionPointParams): {
+            x: number;
+            y: number;
+        };
+        getRectHJoinPoint(params: import('./utils/RGGraphMath').CreateJunctionPointParams): {
+            x: number;
+            y: number;
+        };
+        getRectLeftJoinPoint(params: import('./utils/RGGraphMath').CreateJunctionPointParams): {
+            x: number;
+            y: number;
+        };
+        getRectRightJoinPoint(params: import('./utils/RGGraphMath').CreateJunctionPointParams): {
+            x: number;
+            y: number;
+        };
+        getRectTopJoinPoint(params: import('./utils/RGGraphMath').CreateJunctionPointParams): {
+            x: number;
+            y: number;
+        };
+        getRectBottomJoinPoint(params: import('./utils/RGGraphMath').CreateJunctionPointParams): {
+            x: number;
+            y: number;
+        };
+        getRectHorizontalLineJoinPoint(params: import('./utils/RGGraphMath').CreateJunctionPointParams): {
+            x: number;
+            y: number;
+        };
+        getRectVJoinPoint(params: import('./utils/RGGraphMath').CreateJunctionPointParams): {
+            y: number;
+            x: number;
+        };
+        getBorderPoint(x1: number, y1: number, x2: number, y2: number, n1w: number, n1h: number, n2w: number, n2h: number, n1style: number): {
+            x: number;
+            y: number;
+        };
+        getBorderPoint4MultiLine(params: import('./utils/RGGraphMath').CreateJunctionPointParams): {
+            x: number;
+            y: number;
+        };
+        getCirclePoint(x1: number, y1: number, x2: number, y2: number, n1w: number, n1h: number, n2w: number, n2h: number): {
+            x: number;
+            y: number;
+        };
+        getCirclePoint4MultiLine(x1: number, y1: number, x2: number, y2: number, n1w: number, n1h: number, n2w: number, n2h: number, isReverse: boolean, totalLines: number, currentIndex: number, lineDistance: number, isEndPoint: boolean): {
+            x: number;
+            y: number;
+        };
+        getCirclePointBasic(x1: number, y1: number, x2: number, y2: number, n1w: number, n1h: number, n2w: number, n2h: number, radius: number): {
+            x: number;
+            y: number;
+        };
+        getCirclePointPlus(x1: number, y1: number, x2: number, y2: number, n1w: number, n1h: number, n2w: number, n2h: number): {
+            x: number;
+            y: number;
+        };
+        getOvalPoint(c_x: number, c_y: number, c_r: number, c_i: number, c_n: number, startAngle?: number): {
+            x: number;
+            y: number;
+        };
+        getAngleType(buffer_x: number, buffer_y: number): 1 | 2 | 3 | 4 | undefined;
+        getTextAngle(fx: number, fy: number, tx: number, ty: number): number;
+    };
+    RGNodesAnalyticUtils: {
+        getDescendantNodes(node: import('packages/platforms/vue2/src').RGNode, collectList?: import('packages/platforms/vue2/src').RGNode[]): import('packages/platforms/vue2/src').RGNode[];
+        conductStrengthToParents(node: import('packages/platforms/vue2/src').RGNode): void;
+        analysisDataTree(thisLevelNodes: import('packages/platforms/vue2/src').RGNode[], thisDeep: number, levelDirect?: import('./utils/RGNodesAnalytic').RGLevelDirection): void;
+        conductStrengthToParents4Folder(node: import('packages/platforms/vue2/src').RGNode): void;
+        analysisDataFolder(thisLevelNodes: import('packages/platforms/vue2/src').RGNode[], thisDeep: number, levelDirect: import('./utils/RGNodesAnalytic').RGLevelDirection): void;
+        isVisibleNode(thisNode: import('packages/platforms/vue2/src').RGNode, deep?: number): boolean;
+        isAllowShowNode(thisNode: import('packages/platforms/vue2/src').RGNode, deep?: number): boolean;
+        getNodeWidth(thisNode: import('packages/platforms/vue2/src').RGNode): number;
+        getNodeHeight(thisNode: import('packages/platforms/vue2/src').RGNode): number;
+        getNodeXByLotX(nodeAlignOption: {
+            alignItemsX: "start" | "center" | "end";
+        }, thisNode: import('packages/platforms/vue2/src').RGNode): number;
+        getNodeYByLotY(nodeAlignOption: {
+            alignItemsY: "start" | "center" | "end";
+        }, thisNode: import('packages/platforms/vue2/src').RGNode): number;
+        getNodeLotXY(nodeAlignOption: import('packages/platforms/vue2/src').RGLayoutOptions4Alignable, node: import('packages/platforms/vue2/src').RGNode): {
+            x: number;
+            y: number;
+        };
+        isRectangleOverlap(rectA: any, rectB: any): boolean;
+        isXOverlap(aX: number, bX: number, a_W: number, b_W: number): boolean;
+        isYOverlap(aY: number, bY: number, a_H: number, b_H: number): boolean;
+        shapesOverlap(nodeA: any, nodeB: any, shapeA?: number, shapeB?: number): boolean;
+        getNoOverlapLimitedPosition(rectA: any, newX: any, newY: any, rectB: any): {
+            x: any;
+            y: any;
+        };
+        flatNodeData(orign_nodes: import('packages/platforms/vue2/src').JsonNode[], parentNode: import('packages/platforms/vue2/src').JsonNode | null, nodes_collect: import('packages/platforms/vue2/src').JsonNode[], links_collect: import('packages/platforms/vue2/src').JsonLine[]): void;
+    };
+    RGEffectUtils: {
+        startDrag(e: MouseEvent | TouchEvent, startPositionModel: import('./utils/RGDragUtils').RGDataModelWithPosition, ondraged: import('./utils/RGDragUtils').RGDragedCallback, ondragging: import('./utils/RGDragUtils').RGDraggingCallback | undefined): void;
+        onNodeMove(e: MouseEvent | TouchEvent): void;
+        onNodeDragend(e: MouseEvent | TouchEvent): void;
+    };
+};

package/types/packages/relation-graph-models/constants.d.ts

@@ -0,0 +1 @@
+export { version } from '../../package.json';

package/types/packages/relation-graph-models/layouters/RGBaseLayouter.d.ts

@@ -0,0 +1,36 @@
+import { CalcNode, RelationGraphInstance, RGLayouter, RGLayoutOptions, RGLink, RGNode, RGOptionsFull } from '../types';
+import { NodesAnalyticResult } from '../utils/RGNodesAnalytic';
+export declare class RGBaseLayouter implements RGLayouter {
+    graphOptions: RGOptionsFull;
+    layoutOptions: RGLayoutOptions;
+    graphInstance: RelationGraphInstance;
+    allNodes: RGNode[];
+    isMainLayouer: boolean;
+    requireLinks: boolean;
+    allLinks: RGLink[];
+    constructor(layoutOptions: RGLayoutOptions, graphOptions: RGOptionsFull, graphInstance: RelationGraphInstance);
+    rootNode: RGNode | undefined;
+    setLinks(links: RGLink[]): void;
+    placeNodes(allNodes: RGNode[], rootNode?: RGNode): void;
+    doLayout(allNodes: RGNode[], rootNode?: RGNode): void;
+    analysisNodes(eachedNodes: RGNode[], thisLevelNodes: RGNode[], thisDeep: number, analyticResult: NodesAnalyticResult): void;
+    generateCalcNodes<CustomCalcNode extends CalcNode>(groupNodes: RGNode[]): {
+        calcNodes: CustomCalcNode[];
+        calcNodeMap: Map<string, CustomCalcNode>;
+    };
+    generateLevels(groupNodes: RGNode[]): {
+        levels: number[];
+        levelNodesMap: Map<number, RGNode[]>;
+    };
+    /**
+     * 修正一排/一列重叠的节点坐标, 并保持固定间距
+     * * @param levelNodes 要处理的节点数组。
+     * 函数假定此数组的 *顺序* 已经是您期望的布局顺序。
+     * @param direction 布局方向 (left, right, top, bottom)
+     * @param gap 节点之间的间距
+     * @returns 返回一个 *新的* 数组, 包含修正了坐标的节点
+     */
+    adjustNodePositions(levelNodes: CalcNode[], direction: 'left' | 'right' | 'top' | 'bottom', gap: number): CalcNode[];
+    getReverseAlignItems(alignItems: 'start' | 'center' | 'end'): string;
+}
+export default RGBaseLayouter;

package/types/packages/relation-graph-models/layouters/RGCenterLayouter.d.ts

@@ -0,0 +1,12 @@
+import { default as RGForceLayouter } from './RGForceLayouter';
+import { NodesAnalyticResult } from '../utils/RGNodesAnalytic';
+import { RelationGraphInstance, RGCenterLayoutOptions, RGLayoutOptions, RGNode, RGOptionsFull } from '../types';
+export declare class RGCenterLayouter extends RGForceLayouter {
+    layoutOptions: RGCenterLayoutOptions;
+    constructor(layoutOptions: RGLayoutOptions, graphOptions: RGOptionsFull, graphInstance: RelationGraphInstance);
+    placeNodes(allNodes: RGNode[], rootNode?: RGNode): void;
+    private getLevelDistanceArr;
+    getLevelR(levelDistanceArr: number[], level: number): number | undefined;
+    placeRelativePosition(rootNode: RGNode, groupNodes: RGNode[], analyticResult: NodesAnalyticResult): void;
+}
+export default RGCenterLayouter;

package/types/packages/relation-graph-models/layouters/RGCircleLayouter.d.ts

@@ -0,0 +1,8 @@
+import { default as RGForceLayouter } from './RGForceLayouter';
+import { RelationGraphInstance, RGLayoutOptions, RGNode, RGOptionsFull } from '../types';
+export declare class RGCircleLayouter extends RGForceLayouter {
+    constructor(layoutOptions: RGLayoutOptions, graphOptions: RGOptionsFull, graphInstance: RelationGraphInstance);
+    refresh(): void;
+    placeNodes(allNodes: RGNode[], rootNode?: RGNode): void;
+}
+export default RGCircleLayouter;

package/types/packages/relation-graph-models/layouters/RGFixedLayouter.d.ts

@@ -0,0 +1,11 @@
+import { default as RGBaseLayouter } from './RGBaseLayouter';
+import { RelationGraphInstance, RGLayoutOptions, RGNode, RGOptionsFull } from '../types';
+export declare class RGFixedLayouter extends RGBaseLayouter {
+    constructor(layoutOptions: RGLayoutOptions, graphOptions: RGOptionsFull, graphInstance: RelationGraphInstance);
+    graphOptions: RGOptionsFull;
+    layoutOptions: RGLayoutOptions;
+    allNodes: never[];
+    __origin_nodes: RGNode[];
+    placeNodes(allNodes: RGNode[], rootNode?: RGNode): void;
+}
+export default RGFixedLayouter;

package/types/packages/relation-graph-models/layouters/RGFolderLayouter.d.ts

@@ -0,0 +1,17 @@
+import { NodesAnalyticResult, RGLevelDirection } from '../utils/RGNodesAnalytic';
+import { default as RGBaseLayouter } from './RGBaseLayouter';
+import { RelationGraphInstance, RGNode, RGOptionsFull, RGTreeLayoutOptions } from '../types';
+export declare class RGFolderLayouter extends RGBaseLayouter {
+    constructor(layoutOptions: RGTreeLayoutOptions, graphOptions: RGOptionsFull, graphInstance: RelationGraphInstance);
+    enableGatherNodes: boolean;
+    layoutOptions: RGTreeLayoutOptions;
+    analysisNodes4Didirectional(willLayoutNodes: RGNode[], thisLevelNodes: RGNode[], thisDeep: number, analyticResult: NodesAnalyticResult, levelDirect: RGLevelDirection): void;
+    placeNodes(allNodes: RGNode[], rootNode?: RGNode): void;
+    placeRelativePosition(rootNode: RGNode, groupNodes: RGNode[], analyticResult: NodesAnalyticResult): void;
+    gatherNodes(groupNodes: RGNode[], hv: 'h' | 'v', perSize: number): void;
+    getBloomingNearByParent(node: RGNode, parentNode: RGNode, levelNodes: RGNode[], hv: 'h' | 'v'): RGNode | undefined;
+    getLevelDistance(level: number, levelMaxWidthMap: Map<number, number>, defaultGap: number): number;
+    private getLevelGap;
+    analysisNodesForFolder(eachedNodes: RGNode[], thisLevelNodes: RGNode[], thisDeep: number, analyticResult: NodesAnalyticResult): void;
+}
+export default RGFolderLayouter;

package/types/packages/relation-graph-models/layouters/RGForceLayouter.d.ts

@@ -0,0 +1,71 @@
+import { NodesAnalyticResult, RGLevelDirection } from '../utils/RGNodesAnalytic';
+import { default as RGBaseLayouter } from './RGBaseLayouter';
+import { CalcNode, RelationGraphInstance, RGEventNames, RGForceLayoutOptions, RGLayoutOptions, RGNode, RGOptionsFull } from '../types';
+type CalcNode4Force = CalcNode & {
+    Fx: number;
+    Fy: number;
+    dragging: boolean;
+    force_weight: number;
+    forceCenterOffset_X: number;
+    forceCenterOffset_Y: number;
+    fixed: boolean;
+};
+export declare class RGForceLayouter extends RGBaseLayouter {
+    layoutOptions: RGForceLayoutOptions;
+    fastStart: boolean;
+    skipInitLayout: boolean;
+    maxLayoutTimes: number;
+    byNode: boolean;
+    byLine: boolean;
+    lockX: boolean;
+    lockY: boolean;
+    force_node_repulsion: number;
+    force_line_elastic: number;
+    stopWhenBalanced: boolean;
+    constructor(layoutOptions: RGLayoutOptions, graphOptions: RGOptionsFull, graphInstance: RelationGraphInstance);
+    calcNodes: RGNode[];
+    placeNodes(calcNodes: RGNode[], rootNode?: RGNode): void;
+    easyAnalysisNodes(rootNode: RGNode): RGNode[];
+    easyPlaceRelativePosition(rootNode: RGNode, groupNodes: RGNode[]): void;
+    protected graphEventHandle(eventName: RGEventNames, ...args: any[]): void;
+    protected _graphEventHandler: any;
+    protected connectToGraphInstance(): void;
+    protected disConnectToGraphInstance(): void;
+    layoutTimes: number;
+    prev10: number[];
+    visibleNodes: RGNode[];
+    updateVisibleNodes(allNode?: RGNode[]): void;
+    viewUpdate(): void;
+    autoLayout(forceLayout?: boolean): void;
+    protected _onFinishCallback: () => void;
+    onFinish(onFinishCallback: () => void): void;
+    _onTickCallback: () => void;
+    onTick(_onTickCallback: () => void): void;
+    applyFBuffToNodes(): void;
+    applyPositionToNodes(): void;
+    protected layoutFinished(): void;
+    protected resetCalcNodes(): void;
+    protected calcNodeMap: WeakMap<RGNode, CalcNode4Force>;
+    protected forCalcNodes: CalcNode4Force[];
+    protected recentGraphVelocity: number[];
+    protected graphVelocityBalancedValue: number;
+    start(): void;
+    doForceLayout(useTime: number): void;
+    private animationFrameTimer;
+    private prevNodeLevel1Index;
+    private prevNodeLevel2Index;
+    calcNodesPosition(): boolean;
+    stop(): void;
+    addElasticByLine(node1: CalcNode4Force, node2: CalcNode4Force, force_elastic?: number): void;
+    maxVaildLineLength: number;
+    minVaildLineLength: number;
+    zeroEffectNodeDistance: number;
+    minNodeDistance: number;
+    maxMoveSpeed: number;
+    n2nMaxForce: number;
+    addGravityByNode(node1: CalcNode4Force, node2: CalcNode4Force, coefficient?: number): void;
+    addFtoNode(node: CalcNode4Force, x: number, y: number): void;
+    applyToNodePosition(node: CalcNode4Force): 0 | undefined;
+    analysisNodes4Didirectional(willLayoutNodes: RGNode[], thisLevelNodes: RGNode[], thisDeep: number, analyticResult: NodesAnalyticResult, levelDirect: RGLevelDirection): void;
+}
+export default RGForceLayouter;

package/types/packages/relation-graph-models/layouters/RGForceLayouterV2.d.ts

@@ -0,0 +1,59 @@
+import { default as RGBaseLayouter } from './RGBaseLayouter';
+import { RGForceLayoutOptions, RGLayoutOptions, RGNode, RelationGraphInstance, RGOptionsFull } from '../types';
+type CalcNode = {
+    rgNode: RGNode;
+    Fx: number;
+    Fy: number;
+    x: number;
+    y: number;
+    ignoreForce: boolean;
+    force_weight: number;
+    fixed: boolean;
+};
+export declare class RGForceLayouterV2 extends RGBaseLayouter {
+    layoutOptions: RGForceLayoutOptions;
+    fastStart: boolean;
+    maxLayoutTimes: number;
+    byNode: boolean;
+    byLine: boolean;
+    lockX: boolean;
+    lockY: boolean;
+    force_node_repulsion: number;
+    force_line_elastic: number;
+    justLayoutSingleNode: boolean;
+    stopWhenBalanced: boolean;
+    barnesHutTheta: number;
+    constructor(layoutOptions: RGLayoutOptions, graphOptions: RGOptionsFull, graphInstance: RelationGraphInstance);
+    placeNodes(allNodes: RGNode[], rootNode?: RGNode): void;
+    layoutTimes: number;
+    prev10: number[];
+    visibleNodes: RGNode[];
+    updateVisibleNodes(allNodesInput?: RGNode[]): void;
+    viewUpdate(): void;
+    autoLayout(forceLayout?: boolean): void;
+    protected _onFinishCallback?: () => void;
+    onFinish(onFinishCallback: () => void): void;
+    applyFBuffToNodes(): void;
+    applyPositionToNodes(): void;
+    _onTickCallback: () => void;
+    onTick(_onRTickCallback: () => void): void;
+    protected layoutFinished(): void;
+    protected resetCalcNodes(): void;
+    protected calcNodeMap: WeakMap<RGNode, CalcNode>;
+    protected forCalcNodes: CalcNode[];
+    doForceLayout(time: number): void;
+    calcNodesPosition(): void;
+    private calculateRepulsionForceRecursive;
+    private applyOriginalRepulsion;
+    private applyRepulsionFromSuperNode;
+    stop(): void;
+    addElasticByLine(node1: CalcNode, node2: CalcNode, force_elastic_coefficient?: number): void;
+    maxVaildLineLength: number;
+    minVaildLineLength: number;
+    zeroEffectNodeDistance: number;
+    minNodeDistance: number;
+    maxMoveSpeed: number;
+    addFtoNode(node: CalcNode, x: number, y: number): void;
+    applyToNodePosition(node: CalcNode): void;
+}
+export default RGForceLayouterV2;

package/types/packages/relation-graph-models/layouters/RGSmartTreeLayouter.d.ts

@@ -0,0 +1,16 @@
+import { NodesAnalyticResult } from '../utils/RGNodesAnalytic';
+import { default as RGBaseLayouter } from './RGBaseLayouter';
+import { RelationGraphInstance, RGNode, RGOptionsFull, RGTreeLayoutOptions } from '../types';
+export declare class RGSmartTreeLayouter extends RGBaseLayouter {
+    constructor(layoutOptions: RGTreeLayoutOptions, graphOptions: RGOptionsFull, graphInstance: RelationGraphInstance);
+    graphInstance: RelationGraphInstance;
+    layoutOptions: RGTreeLayoutOptions;
+    levelDistanceArr: number[];
+    analysisNodes4Didirectional(willLayoutNodes: RGNode[], thisLevelNodes: RGNode[], thisDeep: number, analyticResult: NodesAnalyticResult): void;
+    analysisBothWay(willLayoutNodes: RGNode[], thisLevelNodes: RGNode[], thisDeep: number, analyticResult: NodesAnalyticResult): void;
+    placeNodes(allNodes: RGNode[], rootNode?: RGNode): void;
+    placeNodesPosition(rootNode: RGNode, groupNodes: RGNode[], analyticResult: NodesAnalyticResult): void;
+    placeRelativePosition(rootNode: RGNode, groupNodes: RGNode[], analyticResult: NodesAnalyticResult): void;
+    getLevelDistance(node: RGNode, level: number, perSize: number): number;
+}
+export default RGSmartTreeLayouter;

package/types/packages/relation-graph-models/layouters/RGTreeLayouter.d.ts

@@ -0,0 +1,18 @@
+import { NodesAnalyticResult, RGLevelDirection } from '../utils/RGNodesAnalytic';
+import { default as RGBaseLayouter } from './RGBaseLayouter';
+import { RelationGraphInstance, RGNode, RGOptionsFull, RGTreeLayoutOptions } from '../types';
+export declare class RGTreeLayouter extends RGBaseLayouter {
+    constructor(layoutOptions: RGTreeLayoutOptions, graphOptions: RGOptionsFull, graphInstance: RelationGraphInstance);
+    enableGatherNodes: boolean;
+    layoutOptions: RGTreeLayoutOptions;
+    analysisNodes4Didirectional(willLayoutNodes: RGNode[], thisLevelNodes: RGNode[], thisDeep: number, analyticResult: NodesAnalyticResult, deepFindDirect: RGLevelDirection): void;
+    placeNodes(allNodes: RGNode[], rootNode?: RGNode): void;
+    placeNodesPosition(rootNode: RGNode, groupNodes: RGNode[], analyticResult: NodesAnalyticResult): void;
+    placeRelativePosition(rootNode: RGNode, groupNodes: RGNode[], analyticResult: NodesAnalyticResult): void;
+    getLevelDistance(level: number, levelMaxSizeMap: Map<number, number>, defaultGap: number): number;
+    private getLevelGap;
+    applyNodesGap(groupNodes: RGNode[], hv: 'h' | 'v'): void;
+    gatherNodes(groupNodes: RGNode[], hv: 'h' | 'v', perSize: number): void;
+    getBloomingNearByParent(node: RGNode, parentNode: RGNode, levelNodes: RGNode[], hv: 'h' | 'v'): RGNode | undefined;
+}
+export default RGTreeLayouter;

package/types/packages/relation-graph-models/models/RGLineDataUtils.d.ts

@@ -0,0 +1,9 @@
+import { JsonLine, RGLine, RGLink } from '../types';
+export declare const json2Line: (originData: JsonLine) => RGLine;
+export declare const transLineToJson: (line: RGLine) => JsonLine | undefined;
+export declare const transLinkToJson: (link: RGLink, lineJsonArray: JsonLine[]) => void;
+declare const _default: {
+    json2Line: (originData: JsonLine) => RGLine;
+    transLinkToJson: (link: RGLink, lineJsonArray: JsonLine[]) => void;
+};
+export default _default;

package/types/packages/relation-graph-models/models/RGNodeDataUtils.d.ts

@@ -0,0 +1,14 @@
+import { JsonNode, RGNode, RGOptions } from '../types';
+export declare const newNodeTemplate: {
+    id: string;
+    x: number;
+    y: number;
+    text: string;
+};
+export declare const json2Node: (originData: JsonNode, graphOptions?: RGOptions) => RGNode;
+export declare const transNodeToJson: (node: RGNode) => JsonNode | undefined;
+declare const _default: {
+    json2Node: (originData: JsonNode, graphOptions?: RGOptions) => RGNode;
+    transNodeToJson: (node: RGNode) => JsonNode | undefined;
+};
+export default _default;

package/types/packages/relation-graph-models/models/RGOptionsDataUtils.d.ts

@@ -0,0 +1,11 @@
+import { RGLayoutOptions, RGOptions, RGOptionsFull } from '../types';
+export declare const createDefaultConfig: (userOptions: RGOptions) => RGOptionsFull;
+export declare const applyDefaultOptionsByLayout: (thisLayout: RGLayoutOptions, _options: RGOptionsFull) => void;
+export declare const appendDefaultOptions4Layout: (layoutOptions: RGLayoutOptions) => void;
+export declare const newInstanceOptions: (options: RGOptions) => RGOptionsFull;
+declare const _default: {
+    newInstanceOptions: (options: RGOptions) => RGOptionsFull;
+    createDefaultConfig: (userOptions: RGOptions) => RGOptionsFull;
+    applyDefaultOptionsByLayout: (thisLayout: RGLayoutOptions, _options: RGOptionsFull) => void;
+};
+export default _default;

package/types/packages/relation-graph-models/models/RelationGraphBase.d.ts

@@ -0,0 +1,67 @@
+import { RGEventEmitHook, RGEventHandler, RGEventNames, RGListeners, RGOptions, RGOptionsFull } from '../types';
+export declare class RelationGraphBase {
+    options: RGOptionsFull;
+    listeners: RGListeners;
+    isReact: boolean;
+    constructor(options: RGOptions, listeners: RGListeners);
+    /**
+     * * Enable or disable logging functionality
+     * @param enable
+     */
+    enableDebugLog(enable: boolean): void;
+    /**
+     * Protected method, For react only
+     */
+    protected updateViewHook: () => void;
+    /**
+     * * Used to trigger the external function for updating the view (currently only for React)
+     * @param hook
+     */
+    setUpdateViewHook(hook: () => void): void;
+    protected _dataUpdating: boolean;
+    protected _dataUpdatingNext: boolean;
+    /**
+     * Trigger view update
+     * @private
+     */
+    protected _dataUpdated(): void;
+    /**
+     * Trigger view update
+     * @private
+     */
+    private _doSomethingAfterDataUpdated;
+    protected eventHandlers: RGEventHandler[];
+    /**
+     * * Register event handler
+     * @param handler: RGEventHandler
+     */
+    addEventHandler(handler: RGEventHandler): void;
+    /**
+     * * Remove event handler
+     * @param handler: RGEventHandler
+     */
+    removeEventHandler(handler: RGEventHandler): void;
+    protected _emitHook: RGEventEmitHook;
+    /**
+     * * Set the event hook, For Vue2,Vue3 only
+     * @param emitHook
+     */
+    setEventEmitHook(emitHook: RGEventEmitHook): void;
+    /**
+     * Trigger event
+     * @param eventName Name of the event
+     * @param object Parameters passed to the event handler
+     */
+    emitEvent(eventName: RGEventNames, ...args: any[]): boolean | import('../types').RGCoordinate | undefined;
+    /**
+     * Protected Method to trigger the default event handler, i.e., trigger the events set in jsx
+     * @param eventName
+     * @param args
+     * @protected
+     */
+    protected defaultEventHandler(eventName: RGEventNames, ...args: any[]): {
+        result: boolean | void | import('../types').RGCoordinate;
+        handled: boolean;
+    };
+    setEventListener(handler: RGListeners): void;
+}

package/types/packages/relation-graph-models/models/RelationGraphFinal.d.ts

@@ -0,0 +1,11 @@
+import { RGListeners, RGOptions } from '../types';
+import { RelationGraphWith92MiniView } from './RelationGraphWith92MiniView';
+export declare class RelationGraphFinal extends RelationGraphWith92MiniView {
+    constructor(options: RGOptions, listeners: RGListeners);
+    setListeners(listeners: RGListeners): void;
+    /**
+      * [Used internally by relation-graph], this method will be called to initialize some configurations based on options (such as creating a layouter based on the options.layout configuration), and to obtain information such as viewport size.
+      */
+    ready(): void;
+    beforeUnmount(): void;
+}

package/types/packages/relation-graph-models/models/RelationGraphReact.d.ts

@@ -0,0 +1,5 @@
+import { RGListeners, RGOptions } from '../types';
+import { RelationGraphFinal } from './RelationGraphFinal';
+export declare class RelationGraphReact extends RelationGraphFinal {
+    constructor(options: RGOptions, listeners: RGListeners);
+}

package/types/packages/relation-graph-models/models/RelationGraphWith1Dom.d.ts

@@ -0,0 +1,76 @@
+import { RelationGraphBase } from './RelationGraphBase';
+import { RGLine, RGListeners, RGNode, RGOptions } from '../types';
+export declare class RelationGraphWith1Dom extends RelationGraphBase {
+    $dom: HTMLDivElement;
+    $canvasDom: HTMLDivElement;
+    protected resizeObserver: ResizeObserver;
+    protected resizeListenerMap: WeakMap<object, any>;
+    protected domToNodeIdMap: WeakMap<Element, string>;
+    constructor(options: RGOptions, listeners: RGListeners);
+    protected initDom(): void;
+    _rgAsConnectArea: boolean;
+    /**
+     * [Used internally by relation-graph] This method will be called after the RelationGraph component is mounted, to facilitate DOM operations in the JS instance object (this will only obtain visual information of the DOM and monitor changes in size and position).
+     * @param relationGraphDom:HTMLDivElement RelationGraph container DOM
+     */
+    setDom(relationGraphDom: HTMLDivElement): void;
+    private onKeyDownHanlder;
+    private onKeyUpHanlder;
+    protected addKeyboardListener(): void;
+    protected removeKeyboardListener(): void;
+    /**
+     * [Used internally by relation-graph] This method will be called after the RelationGraph component's canvas element is mounted, to facilitate DOM operations in the JS instance object (this will only obtain visual information of the DOM and monitor changes in size and position).
+     * @param relationGraphDom:HTMLDivElement canvas DOM
+     */
+    setCanvasDom(canvasDom: HTMLDivElement): void;
+    $lineTextContainer4NormalLine: HTMLDivElement;
+    $lineTextContainer4FakeLine: HTMLDivElement;
+    getLineTextContainer(line: RGLine): HTMLDivElement | undefined;
+    /**
+     * Get the RelationGraph component DOM
+     * @return relationGraphDom:HTMLDivElement RelationGraph container DOM
+     */
+    getBoundingClientRect(): DOMRect;
+    /**
+     * Monitor the size changes of a DOM element using ResizeObserver
+     * @param dom
+     * @param callback
+     * @protected
+     */
+    protected addResizeListener(dom: HTMLElement, callback: (width: number, height: number) => void): void;
+    /**
+     * Node DOM resize event handler
+     * @param dom
+     * @param width
+     * @param height
+     * @private
+     */
+    private _onNodeDomResize;
+    /**
+     * Node DOM resize event handler
+     * @param dom
+     * @param node
+     * @param width
+     * @param height
+     * @private
+     */
+    private _onNodeResize;
+    /**
+     * [Used internally by relation-graph] This method is called when the Node component is mounted to monitor changes in the size of the Node's DOM element.
+     * @param dom The DOM element corresponding to the Node component
+     * @param node The JS data object of the Node
+     */
+    addNodeResizeListener(dom: HTMLElement, node: RGNode): void;
+    /**
+     * [Used internally by relation-graph] This method is called when the Node component is destroyed to remove monitoring of the corresponding DOM element of the Node.
+     * @param dom The DOM element corresponding to the Node component
+     */
+    removeNodeResizeListener(dom: HTMLElement): void;
+    /**
+     * Remove size change monitoring for the DOM element
+     * @param dom
+     * @protected
+     */
+    protected removeResizeListener(dom: HTMLElement): void;
+    protected destroyResizeObserver(): void;
+}