@relation-graph/vue3 3.0.4

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

@@ -0,0 +1,140 @@
+import { default as BaseLayout } from './layouts/RGBaseLayout';
+import { default as BidirectionalTreeLayout } from './layouts/RGTreeLayout';
+import { default as CenterLayout } from './layouts/RGCenterLayout';
+import { default as CircleLayout } from './layouts/RGCircleLayout';
+import { default as FixedLayout } from './layouts/RGFixedLayout';
+import { default as ForceLayout } from './layouts/RGForceLayout';
+import { default as RGFolderLayout } from './layouts/RGFolderLayout';
+import { RGNetworkAnalyzer as _RGNetworkAnalyzer } from './layouts/analyzers/RGNetworkAnalyzer';
+import * as RGOptionsDataUtils from "./data/RGOptionsDataUtils";
+import * as RGLineDataUtils from "./data/RGLineDataUtils";
+import * as RGNodeDataUtils from "./data/RGNodeDataUtils";
+export type RGNetworkAnalyzer = _RGNetworkAnalyzer;
+export declare const RGLayouts: {
+    BaseLayout: typeof BaseLayout;
+    BidirectionalTreeLayout: typeof BidirectionalTreeLayout;
+    CenterLayout: typeof CenterLayout;
+    CircleLayout: typeof CircleLayout;
+    FixedLayout: typeof FixedLayout;
+    ForceLayout: typeof ForceLayout;
+    RGFolderLayout: typeof RGFolderLayout;
+};
+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): {
+            y: number;
+            x: number;
+        };
+        getRectVerticalLineLineJoinPoint(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;
+        };
+        getRotatedPoint(x: number, y: number, c_x: number, c_y: number, rotateDeg: number): {
+            x: number;
+            y: number;
+        };
+        getFlippedX(x: number, c_x: number): number;
+        getFlippedY(y: number, c_y: number): 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('../types').RGNode, collectList?: import('../types').RGNode[]): import('../types').RGNode[];
+        isVisibleNode(thisNode: import('../types').RGNode, deep?: number): boolean;
+        isAllowShowNode(thisNode: import('../types').RGNode, deep?: number): boolean;
+        getNodeWidth(thisNode: import('../types').RGNode): number;
+        getNodeHeight(thisNode: import('../types').RGNode): number;
+        getNodeXByLotX(nodeAlignOption: {
+            alignItemsX: "start" | "center" | "end";
+        }, thisNode: import('../types').RGNode): number;
+        getNodeYByLotY(nodeAlignOption: {
+            alignItemsY: "start" | "center" | "end";
+        }, thisNode: import('../types').RGNode): number;
+        getNodeLotXY(nodeAlignOption: import('../types').RGLayoutOptions4Alignment, node: import('../types').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(orignNodes: import('../types').JsonNode[], parentNode: import('../types').JsonNode | null, nodesCollect: import('../types').JsonNode[], linksCollect: import('../types').JsonLine[]): void;
+    };
+    RGEffectUtils: {
+        startDrag(e: MouseEvent | TouchEvent, startPositionOrModel: import('../types').RGCoordinate, onDragged: import('./utils/RGDragUtils').RGDraggedCallback, 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/data/RGDataDefine.d.ts

@@ -0,0 +1,23 @@
+import { RGGraphData, RGNode, RGLine, RGLink, RGOptionsFull, RGFakeLine, RGConnectTargetData, RGLineTarget } from '../../types';
+/**
+ * 数据提供者
+ * 专门负责数据的增删改查，并自动触发视图更新
+ */
+export declare class RGDataDefine {
+    constructor();
+    /**
+     * All data managed in RelationGraph, including all nodes RGNode, all relationships RGLink, the current root node, and all element lines elementLines
+     */
+    protected graphData: RGGraphData;
+    protected options: RGOptionsFull;
+    protected runtimeDATA4NodeMap: Map<string, RGNode>;
+    protected runtimeDATA4Links: RGLink[];
+    protected runtimeDATA4LinkMap: Map<string, RGLink>;
+    protected runtimeDATA4ConnectTargets: RGConnectTargetData[];
+    protected runtimeDATA4ElLineTargets: RGLineTarget[];
+    protected runtimeDATA4ShouldRenderItems: {
+        nodes: RGNode[];
+        lines: RGLine[];
+        fakeLines: RGFakeLine[];
+    };
+}

package/types/packages/relation-graph-models/data/RGDataGetter.d.ts

@@ -0,0 +1,36 @@
+import { RGNode, RGLine, RGFakeLine, RGConnectTargetData, RGCoordinate } from '../../types';
+import { RGDataDefine } from './RGDataDefine';
+/**
+ * 数据提供者
+ * 专门负责数据的增删改查，并自动触发视图更新
+ */
+export declare class RGDataGetter extends RGDataDefine {
+    constructor();
+    getOptions(): import('../../types').RGOptionsFull;
+    /**
+     * Get the node object by node id
+     * @param nodeId: RGNode
+     */
+    getNodeById(nodeId: string): RGNode | undefined;
+    getLineById(lineId: string): RGLine | undefined;
+    getLinkByLineId(lineId: string): import('../../types').RGLink | undefined;
+    getFakeLineById(lineId: string): RGFakeLine | undefined;
+    getNodes(): RGNode[];
+    getLinks(): import('../../types').RGLink[];
+    getFakeLines(): RGFakeLine[];
+    getLines(): RGLine[];
+    getRootNode(): RGNode | undefined;
+    getShouldRenderNodes(): RGNode[];
+    getShouldRenderLines(): RGLine[];
+    getShouldRenderFakeLines(): RGFakeLine[];
+    isPerformanceMode(): boolean;
+    getCanvasScale(): number;
+    getConnectTargets(): RGConnectTargetData[];
+    getConnectTargetById(targetId: string): RGConnectTargetData | undefined;
+    getElLineTargets(): import('../../types').RGLineTarget[];
+    getElLineTargetById(elId: string): import('../../types').RGLineTarget | undefined;
+    calcShouldRenderNodes(): RGNode[];
+    calcShouldRenderLines(): RGLine[];
+    calcShouldRenderFakeLines(): RGFakeLine[];
+    findNodeByXy(xy: RGCoordinate): RGNode | null;
+}

package/types/packages/relation-graph-models/data/RGDataProvider.d.ts

@@ -0,0 +1,66 @@
+import { RGNode, RGLine, RGOptionsFull, JsonLine, RGConnectTargetData, RGLineTarget } from '../../types';
+import { RGDataGetter } from './RGDataGetter';
+export type DataCommits = {
+    optionsChanged: boolean;
+    changedNodes: string[];
+    nodesListChanged: boolean;
+    changedLines: string[];
+    linesListChanged: boolean;
+    changedFakeLines: string[];
+    fakeLinesListChanged: boolean;
+    changedConnectTargets: string[];
+    connectTargetsListChanged: boolean;
+};
+/**
+ * 数据提供者
+ * 专门负责数据的增删改查，并自动触发视图更新
+ */
+export declare class RGDataProvider extends RGDataGetter {
+    private commits;
+    constructor();
+    /**
+     * Clear all data in RelationGraph, including nodes, lines, element lines, and the root node
+     */
+    clearReactiveData(): void;
+    /**
+     * Protected method, For react only
+     */
+    updateViewHook: (commits: DataCommits) => void;
+    private resetCommints;
+    private commitLine;
+    private commitNode;
+    private commitFakeLine;
+    private commitConnectTarget;
+    dataUpdated(): void;
+    updateOptions(options: Partial<RGOptionsFull>): void;
+    clearChecked(): void;
+    setCanvasOffset(x: number, y: number): void;
+    setCanvasZoom(newValue: number): void;
+    setEditingLine(line: RGLine | null): void;
+    setEditingNodes(nodes: RGNode[]): void;
+    setCanvasCenter(x: number, y: number): void;
+    removeNodeById(nodeIds: string[]): void;
+    removeLineByIds(lineIds: string[]): void;
+    removeFakeLineByIds(lineIds: string[]): void;
+    removeLinkByLineIds(lineIds: string[]): void;
+    removeConnectTarget(targetId: string): void;
+    private updateLinks;
+    private beforeNodeBeRemove;
+    addFakeLines(lines: JsonLine[]): void;
+    clearFakeLines(): void;
+    addNodes(newNodes: RGNode[]): void;
+    addLines(newLines: RGLine[]): void;
+    updateNode(nodeId: string, nodeProperties: Partial<RGNode>): void;
+    updateNodeData(nodeId: string, nodeData: Record<string, any>): void;
+    updateLine(lineId: string, lineProperties: Partial<RGLine>): void;
+    updateLineData(lineId: string, lineData: Record<string, any>): void;
+    updateFakeLine(lineId: string, lineProperties: Partial<RGLine>): void;
+    updateConnectTarget(connectTargetId: string, connectTargetProperties: Partial<RGConnectTargetData>): void;
+    updateElLineTarget(elId: string, targetProperties: Partial<RGLineTarget>): void;
+    updateNodesVisibleProperty(nodes?: RGNode[]): void;
+    private calcLinkVisibility;
+    updateShouldRenderGraphData(): void;
+    addConnectTarget(newConnectTarget: RGConnectTargetData): RGConnectTargetData | undefined;
+    addElLineTarget(elementTarget: RGLineTarget): void;
+    setRootNodeId(rootNodeId: string): void;
+}

package/types/packages/relation-graph-models/data/RGDataProvider4React.d.ts

@@ -0,0 +1,9 @@
+import { ReactiveDataStores } from '../../types';
+import { RGDataProvider } from './RGDataProvider';
+/**
+ * 数据提供者
+ * 专门负责数据的增删改查，并自动触发视图更新
+ */
+export declare class RGDataProvider4React extends RGDataProvider {
+    constructor(dataStores: ReactiveDataStores, updateViewHook: () => void);
+}

package/types/packages/relation-graph-models/data/RGDataProvider4Svelte.d.ts

@@ -0,0 +1,10 @@
+import { ReactiveDataStores, ReactiveDataUpdaters } from '../../types';
+import { RGDataProvider } from './RGDataProvider';
+/**
+ * 数据提供者
+ * 专门负责数据的增删改查，并自动触发视图更新
+ */
+export declare class RGDataProvider4Svelte extends RGDataProvider {
+    dataStores: ReactiveDataStores;
+    constructor(dataStores: ReactiveDataStores, updaters: ReactiveDataUpdaters);
+}

package/types/packages/relation-graph-models/data/RGDataProvider4Vue2.d.ts

@@ -0,0 +1,9 @@
+import { RGGraphData, RGOptions } from '../../types';
+import { RGDataProvider } from './RGDataProvider';
+/**
+ * 数据提供者
+ * 专门负责数据的增删改查，并自动触发视图更新
+ */
+export declare class RGDataProvider4Vue2 extends RGDataProvider {
+    constructor(graphData: RGGraphData, graphOptions: RGOptions, runtimeData: any);
+}

package/types/packages/relation-graph-models/data/RGDataProvider4Vue3.d.ts

@@ -0,0 +1,10 @@
+import { RGGraphData, RGOptions, ReactiveDataStores } from '../../types';
+import { RGDataProvider } from './RGDataProvider';
+/**
+ * 数据提供者
+ * 专门负责数据的增删改查，并自动触发视图更新
+ */
+export declare class RGDataProvider4Vue3 extends RGDataProvider {
+    dataStores: ReactiveDataStores;
+    constructor(dataStores: ReactiveDataStores, graphData: RGGraphData, graphOptions: RGOptions, runtimeData: any);
+}

package/types/packages/relation-graph-models/data/RGDataProvider4Vue3V1.d.ts

@@ -0,0 +1,10 @@
+import { RGGraphData, RGOptions, ReactiveDataStores } from '../../types';
+import { RGDataProvider } from './RGDataProvider';
+/**
+ * 数据提供者
+ * 专门负责数据的增删改查，并自动触发视图更新
+ */
+export declare class RGDataProvider4Vue3 extends RGDataProvider {
+    dataStores: ReactiveDataStores;
+    constructor(dataStores: ReactiveDataStores, graphData: RGGraphData, graphOptions: RGOptions, runtimeData: any);
+}

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

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

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

@@ -0,0 +1,17 @@
+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, nodesSizeMap?: Map<string, [
+    number,
+    number
+]>) => RGNode;
+export declare const transNodeToJson: (node: RGNode) => JsonNode | undefined;
+declare const _default: {
+    json2Node: (originData: JsonNode, graphOptions?: Partial<import('../../types').RGOptionsInited> | undefined, nodesSizeMap?: Map<string, [number, number]> | undefined) => RGNode;
+    transNodeToJson: (node: RGNode) => JsonNode | undefined;
+};
+export default _default;

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

@@ -0,0 +1,7 @@
+import { RGLayoutOptions, RGOptions, RGOptionsFull } from '../../types';
+export declare const createDefaultConfig: (userOptions?: RGOptions) => RGOptionsFull;
+export declare const appendDefaultOptions4Layout: (layoutOptions: RGLayoutOptions) => void;
+declare const _default: {
+    createDefaultConfig: (userOptions?: Partial<import('../../types').RGOptionsInited>) => RGOptionsFull;
+};
+export default _default;

package/types/packages/relation-graph-models/data/utils/EdgeCounter.d.ts

@@ -0,0 +1,8 @@
+export declare class EdgeCounter {
+    map: Map<string, number>;
+    constructor();
+    _key(a: string, b: string): string;
+    addEdge(from: string, to: string): number;
+    getCount(from: string, to: string): number;
+    clear(): void;
+}

package/types/packages/relation-graph-models/layouts/RGBaseLayout.d.ts

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

package/types/packages/relation-graph-models/layouts/RGCenterLayout.d.ts

@@ -0,0 +1,9 @@
+import { default as RGForceLayout } from './RGForceLayout';
+import { RelationGraphInstance, RGCenterLayoutOptions, RGLayoutOptions, RGNode, RGOptionsFull } from '../../types';
+export declare class RGCenterLayout extends RGForceLayout {
+    layoutOptions: RGCenterLayoutOptions;
+    constructor(layoutOptions: RGLayoutOptions, graphOptions: RGOptionsFull, graphInstance: RelationGraphInstance);
+    placeNodes(allNodes: RGNode[], rootNode?: RGNode): void;
+    private getLevelDistanceArr;
+}
+export default RGCenterLayout;

package/types/packages/relation-graph-models/layouts/RGCircleLayout.d.ts

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

package/types/packages/relation-graph-models/layouts/RGFixedLayout.d.ts

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

package/types/packages/relation-graph-models/layouts/RGFolderLayout.d.ts

@@ -0,0 +1,15 @@
+import { default as RGBaseLayout } from './RGBaseLayout';
+import { RelationGraphInstance, RGNode, RGOptionsFull, RGTreeLayoutOptions } from '../../types';
+import { NodesAnalyticResult } from './analyzers/RGNetworkAnalyzer';
+export declare class RGFolderLayout extends RGBaseLayout {
+    constructor(layoutOptions: RGTreeLayoutOptions, graphOptions: RGOptionsFull, graphInstance: RelationGraphInstance);
+    enableGatherNodes: boolean;
+    layoutOptions: RGTreeLayoutOptions;
+    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;
+}
+export default RGFolderLayout;

package/types/packages/relation-graph-models/layouts/RGForceLayout.d.ts

@@ -0,0 +1,82 @@
+import { default as RGBaseLayout } from './RGBaseLayout';
+import { CalcNode, RelationGraphInstance, RGEventNames, RGForceLayoutOptions, RGNode, RGOptionsFull } from '../../types';
+import { NodesAnalyticResult } from './analyzers/RGNetworkAnalyzer';
+type CalcNode4Force = CalcNode & {
+    Fx: number;
+    Fy: number;
+    dragging: boolean;
+    force_weight: number;
+    forceCenterOffset_X: number;
+    forceCenterOffset_Y: number;
+    fixed: boolean;
+};
+export declare class RGForceLayout extends RGBaseLayout {
+    layoutOptions: RGForceLayoutOptions;
+    private fastStart;
+    private skipInitLayout;
+    private maxLayoutTimes;
+    private byNode;
+    private byLine;
+    private lockX;
+    private lockY;
+    private force_node_repulsion;
+    private force_line_elastic;
+    private disableLiveChanges;
+    private force_x_coefficient;
+    private force_y_coefficient;
+    instanceId: string;
+    constructor(layoutOptions: RGForceLayoutOptions, graphOptions: RGOptionsFull, graphInstance: RelationGraphInstance);
+    updateOptions(layoutOptions: Partial<RGForceLayoutOptions>): void;
+    calcNodes: RGNode[];
+    placeNodes(calcNodes: RGNode[], rootNode?: RGNode): void;
+    protected getLevelR(levelDistanceArr: number[], level: number): number | undefined;
+    protected placeRelativePosition(rootNode: RGNode, groupNodes: RGNode[], analyticResult: NodesAnalyticResult, distanceCoefficient: number, levelDistanceArr: number[]): void;
+    private calculateMinimumRadius;
+    protected placeNodesInFanRegion(nodes: RGNode[], startDeg: number, endDeg: number, centerXy: {
+        x: number;
+        y: number;
+    }, level: number, parentStrength: number, levelDistanceArr: number[], deep: number, distanceCoefficient: number, currentR: number): 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;
+    protected 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 prevLogTime;
+    private animationFrameTimer;
+    private prevNodeLevel1Index;
+    private prevNodeLevel2Index;
+    syncNodePosition(nodeId: string, x: number, y: number): void;
+    calcNodesPosition(): false | undefined;
+    private stoped;
+    stop(): void;
+    addElasticByLine(node1: CalcNode4Force, node2: CalcNode4Force, force_elastic?: number): void;
+    maxTractionLength: number;
+    zeroForceLength: number;
+    maxRepulsionDistance: number;
+    nodeCollisionRadius: 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;
+}
+export default RGForceLayout;

package/types/packages/relation-graph-models/layouts/RGIOTreeLayout.d.ts

@@ -0,0 +1,18 @@
+import { default as RGBaseLayout } from './RGBaseLayout';
+import { RelationGraphInstance, RGNode, RGOptionsFull, RGTreeLayoutOptions } from '../../types';
+export declare class RGIOTreeLayout extends RGBaseLayout {
+    constructor(layoutOptions: RGTreeLayoutOptions, graphOptions: RGOptionsFull, graphInstance: RelationGraphInstance);
+    private rotate;
+    enableGatherNodes: boolean;
+    layoutOptions: RGTreeLayoutOptions;
+    placeNodes(allNodes: RGNode[], rootNode: RGNode): void;
+    placeNodesPosition(rootNode: RGNode, groupNodes: RGNode[]): void;
+    placeRelativePosition(rootNode: RGNode, _groupNodes: RGNode[]): void;
+    private buildNetwork;
+    private reduceNodeRect;
+    private placeNodeChildrenV;
+    private placeNodeChildrenH;
+    getLevelDistance(level: number, levelMaxSizeMap: Map<number, number>, defaultGap: number): number;
+    private getLevelGap;
+}
+export default RGIOTreeLayout;

package/types/packages/relation-graph-models/layouts/RGSmartTreeLayout.d.ts

@@ -0,0 +1,14 @@
+import { default as RGBaseLayout } from './RGBaseLayout';
+import { RelationGraphInstance, RGNode, RGOptionsFull, RGTreeLayoutOptions } from '../../types';
+export declare class RGSmartTreeLayout extends RGBaseLayout {
+    constructor(layoutOptions: RGTreeLayoutOptions, graphOptions: RGOptionsFull, graphInstance: RelationGraphInstance);
+    graphInstance: RelationGraphInstance;
+    layoutOptions: RGTreeLayoutOptions;
+    levelGaps: number[];
+    placeNodes(allNodes: RGNode[], rootNode: RGNode): void;
+    placeRelativePosition(rootNode: RGNode, groupNodes: RGNode[], max_strength: number): void;
+    applyNodesGap(groupNodes: RGNode[]): void;
+    getLevelDistance(level: number, levelMaxSizeMap: Map<number, number>, defaultGap: number): number;
+    private getLevelGap;
+}
+export default RGSmartTreeLayout;

package/types/packages/relation-graph-models/layouts/RGTreeLayout.d.ts

@@ -0,0 +1,17 @@
+import { default as RGBaseLayout } from './RGBaseLayout';
+import { RelationGraphInstance, RGNode, RGOptionsFull, RGTreeLayoutOptions } from '../../types';
+import { NodesAnalyticResult } from './analyzers/RGNetworkAnalyzer';
+export declare class RGTreeLayout extends RGBaseLayout {
+    constructor(layoutOptions: RGTreeLayoutOptions, graphOptions: RGOptionsFull, graphInstance: RelationGraphInstance);
+    enableGatherNodes: boolean;
+    layoutOptions: RGTreeLayoutOptions;
+    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 RGTreeLayout;

package/types/packages/relation-graph-models/layouts/analyzers/BasicNetworkAnalyzer.d.ts

@@ -0,0 +1,28 @@
+import { NodesAnalyticResult, RGLevelDirection, RGNetworkAnalyzer } from './RGNetworkAnalyzer';
+import { RelationGraphInstance, RGNode } from '../../../types';
+export declare class BasicNetworkAnalyzer implements RGNetworkAnalyzer {
+    graphInstance: RelationGraphInstance;
+    private initialized;
+    isFolderLayout: boolean;
+    constructor(graphInstance: RelationGraphInstance);
+    analyzeNetwork(nodes: RGNode[], rootNode: RGNode, bothWay?: boolean, deepBothWay?: boolean): {
+        tree: {
+            networkNodes: RGNode[];
+            analyticResult: NodesAnalyticResult;
+        };
+        reverseTree: {
+            networkNodes: never[];
+            analyticResult: NodesAnalyticResult;
+        };
+    };
+    protected markNodeParent(rootNode: RGNode): {
+        networkNodes: RGNode[];
+    };
+    private _markNodeParent;
+    private expandLevelNodesWithDirection;
+    private _appendNodeChildrenToNextLevelNodes;
+    private calcStrengthWithChildsValue;
+    calcStrengthFromValue(rootNode: RGNode, deepFindDirect?: RGLevelDirection): void;
+    private _calcStrengthFromValue;
+    conductStrengthToParents(node: RGNode): void;
+}