@relation-graph/react 3.0.0 → 3.0.1

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

@@ -0,0 +1,36 @@
+import { RGNode, RGLine, RGFakeLine, RGConnectTarget4NodePoint, 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(): RGConnectTarget4NodePoint[];
+    getConnectTargetById(targetId: string): RGConnectTarget4NodePoint | 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, RGConnectTarget4NodePoint, 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<RGConnectTarget4NodePoint>): void;
+    updateElLineTarget(elId: string, targetProperties: Partial<RGLineTarget>): void;
+    updateNodesVisibleProperty(nodes?: RGNode[]): void;
+    private calcLinkVisibility;
+    updateShouldRenderGraphData(): void;
+    addConnectTarget(newConnectTarget: RGConnectTarget4NodePoint): RGConnectTarget4NodePoint | 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,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?: Partial<import('../../types').RGOptionsInited> | undefined) => RGNode;
+    transNodeToJson: (node: RGNode) => JsonNode | undefined;
+};
+export default _default;

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

@@ -0,0 +1,9 @@
+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;
+declare const _default: {
+    createDefaultConfig: (userOptions?: Partial<import('../../types').RGOptionsInited>) => RGOptionsFull;
+    applyDefaultOptionsByLayout: (thisLayout: RGLayoutOptions, _options: RGOptionsFull) => void;
+};
+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,77 @@
+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;
+    fastStart: boolean;
+    skipInitLayout: boolean;
+    maxLayoutTimes: number;
+    byNode: boolean;
+    byLine: boolean;
+    lockX: boolean;
+    lockY: boolean;
+    force_node_repulsion: number;
+    force_line_elastic: number;
+    stopWhenBalanced: boolean;
+    instanceId: string;
+    constructor(layoutOptions: RGForceLayoutOptions, graphOptions: RGOptionsFull, graphInstance: RelationGraphInstance);
+    calcNodes: RGNode[];
+    placeNodes(calcNodes: RGNode[], rootNode?: RGNode): void;
+    protected getLevelR(levelDistanceArr: number[], level: number): number | undefined;
+    protected placeRelativePosition(rootNode: RGNode, groupNodes: RGNode[], analyticResult: NodesAnalyticResult, distance_coefficient: any, levelDistanceArr: any): void;
+    protected placeNodesInFanRegion(nodes: RGNode[], startDeg: number, endDeg: number, centerXy: {
+        x: number;
+        y: number;
+    }, level: number, parentStrength: number, levelDistanceArr: number[], deep: number, distanceCoefficient?: 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;
+    calcNodesPosition(): boolean;
+    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,27 @@
+import { NodesAnalyticResult, RGLevelDirection, RGNetworkAnalyzer } from './RGNetworkAnalyzer';
+import { RelationGraphInstance, RGNode } from '../../../types';
+export declare class BasicNetworkAnalyzer implements RGNetworkAnalyzer {
+    graphInstance: RelationGraphInstance;
+    private initialized;
+    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;
+}

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

@@ -0,0 +1,27 @@
+import { RGNode } from '../../../types';
+export type NodesAnalyticLevel = {
+    level: number;
+    all_size: number;
+    all_strength: number;
+};
+export type NodesAnalyticResult = {
+    direct: number;
+    max_deep: number;
+    min_deep: number;
+    max_length: number;
+    max_strength: number;
+    levels: Map<number, NodesAnalyticLevel>;
+};
+export type RGLevelDirection = -1 | 0 | 1;
+export interface RGNetworkAnalyzer {
+    analyzeNetwork(nodes: RGNode[], rootNode: RGNode, bothWay?: boolean, deepBothWay?: boolean): {
+        tree: {
+            networkNodes: RGNode[];
+            analyticResult: NodesAnalyticResult;
+        };
+        reverseTree: {
+            networkNodes: RGNode[];
+            analyticResult: NodesAnalyticResult;
+        };
+    };
+}

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

@@ -1,32 +1,40 @@
-import { RGEventEmitHook, RGEventHandler, RGEventNames, RGListeners, RGOptions, RGOptionsFull } from '../types';
+import { RGEventEmitHook, RGEventHandler, RGEventNames, RGListeners, RGOptionsFull } from '../../types';
+import { RGDataProvider } from '../data/RGDataProvider';
+/**
+ * relation-graph component base class, providing common API methods
+ */
 export declare class RelationGraphBase {
-    options: RGOptionsFull;
     listeners: RGListeners;
-    isReact: boolean;
-    constructor(options: RGOptions, listeners: RGListeners);
+    private useReactiveDataToAutoUpdateView;
+    protected instanceId: string;
+    dataProvider: RGDataProvider;
+    options: RGOptionsFull;
+    constructor();
+    /**
+     * Generate a highly likely unique id, the probability of non-duplication depends on the parameter idLength (the length of the id)
+     * @param idLength The length of the id, default is 5
+     */
+    generateNewUUID(idLength?: number): string;
     /**
      * * 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
+     * Request view update
+     * Used to update canvas drawing, subsequent canvas drawing will be upgraded to use WebGL to improve performance
+     * @protected
      */
-    setUpdateViewHook(hook: () => void): void;
-    protected _dataUpdating: boolean;
-    protected _dataUpdatingNext: boolean;
+    protected _dataUpdated(): void;
+    private _dataUpdatedRequested;
     /**
-     * Trigger view update
+     * @inner
+     * Reuqest Trigger view update
      * @private
      */
-    protected _dataUpdated(): void;
+    protected _requestDataUpdate(): void;
     /**
-     * Trigger view update
+     * Trigger view update for React/Svelte/Canvas
      * @private
      */
     private _doSomethingAfterDataUpdated;
@@ -52,7 +60,7 @@ export declare class RelationGraphBase {
      * @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 emitEvent(eventName: RGEventNames, ...args: any[]): import('../../types').RGCoordinate | undefined;
     /**
      * Protected Method to trigger the default event handler, i.e., trigger the events set in jsx
      * @param eventName
@@ -60,8 +68,13 @@ export declare class RelationGraphBase {
      * @protected
      */
     protected defaultEventHandler(eventName: RGEventNames, ...args: any[]): {
-        result: boolean | void | import('../types').RGCoordinate;
+        result: void | import('../../types').RGCoordinate;
         handled: boolean;
     };
+    /**
+     * * Set event listeners
+     * @param handler
+     * @inner
+     */
     setEventListener(handler: RGListeners): void;
 }

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

@@ -0,0 +1,46 @@
+import { RGListeners } from '../../types';
+import { RelationGraphWith99API } from './RelationGraphWith99API';
+/**
+ * The final instance class of the relation-graph component, the class that is actually instantiated
+ * - Each <RGProvider><RelationGraph /></RGProvider> component creates and binds a RelationGraphCore instance, which allows the component UI and user to call the API for data logic and interaction
+ * - It will have all the capabilities of the following classes through integration:
+ *      - RelationGraphBase.ts
+ *      - RelationGraphWith1View.ts
+ *      - RelationGraphWith2Data.ts
+ *      - RelationGraphWith2Data1Getter.ts
+ *      - RelationGraphWith2Data2Analysis.ts
+ *      - RelationGraphWith2Data3Update.ts
+ *      - RelationGraphWith2Data4ConnectTarget.ts
+ *      - RelationGraphWith2Data5LineConfig.ts
+ *      - RelationGraphWith3Options1Update.ts
+ *      - RelationGraphWith3Options2API.ts
+ *      - RelationGraphWith4Line.ts
+ *      - RelationGraphWith5Zoom.ts
+ *      - RelationGraphWith6Effect.ts
+ *      - RelationGraphWith6Layout.ts
+ *      - RelationGraphWith7Event.ts
+ *      - RelationGraphWith9EasyView.ts
+ *      - RelationGraphWith91Editing.ts
+ *      - RelationGraphWith92MiniView.ts
+ *      - RelationGraphWith93Image.ts
+ *      - RelationGraphWith95Dom.ts
+ *      - RelationGraphWith99API.ts
+ *
+ */
+export declare class RelationGraphCore extends RelationGraphWith99API {
+    constructor();
+    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 layoutor based on the options.layout configuration), and to obtain information such as viewport size.
+     * @inner
+     */
+    ready(): void;
+    /**
+     * @inner
+     */
+    viewComponentUnmounted: boolean;
+    /**
+     * @inner
+     */
+    beforeUnmount(): void;
+}