@relation-graph/react 3.0.0 → 3.0.1

package/types/packages/platforms/svelte/src/index.d.ts

@@ -0,0 +1,194 @@
+/**
+* relation-graph
+* Website: http://www.relation-graph.com/
+* Github: https://github.com/seeksdream/relation-graph
+*
+*/
+import { default as _RelationGraph } from './core4svelte/RelationGraph.svelte';
+import { RelationGraphCore as _RelationGraphCore } from '../../../relation-graph-models/models/RelationGraphCore';
+import { default as BaseLayout } from '../../../relation-graph-models/layouts/RGBaseLayout';
+import { default as BidirectionalTreeLayout } from '../../../relation-graph-models/layouts/RGTreeLayout';
+import { default as CenterLayout } from '../../../relation-graph-models/layouts/RGCenterLayout';
+import { default as CircleLayout } from '../../../relation-graph-models/layouts/RGCircleLayout';
+import { default as FixedLayout } from '../../../relation-graph-models/layouts/RGFixedLayout';
+import { default as ForceLayout } from '../../../relation-graph-models/layouts/RGForceLayout';
+import { default as RGFolderLayout } from '../../../relation-graph-models/layouts/RGFolderLayout';
+export { default as RGToolBar } from './core4svelte/widgets/GraphXsToolBar.svelte';
+export { default as RGFakeNode } from './core4svelte/RGFakeNode.svelte';
+export { default as RGLinePath } from './core4svelte/RGLinePath.svelte';
+export { default as RGLineText } from './core4svelte/RGLineText.svelte';
+export { default as RGNodeExpandHolder } from './core4svelte/RGNodeExpandHolder.svelte';
+export { default as RGMiniToolBar } from './core4svelte/widgets/GraphXsToolBar.svelte';
+export { default as RGEditingNodeController } from './core4svelte/editing/RGEditingNodeController.svelte';
+export { default as RGEditingResize } from './core4svelte/editing/RGEditingResize.svelte';
+export { default as RGMiniView } from './core4svelte/editing/RGMiniView.svelte';
+export { default as RGMiniViewAsWebComponent } from './core4svelte/web-components/RGMiniView.svelte';
+export { default as RGEditingNodeControllerWebComponenet } from './core4svelte/web-components/RGEditingNodeController.svelte';
+export { default as RGEditingResizeWebComponenet } from './core4svelte/web-components/RGEditingResize.svelte';
+export { default as RGConnectTargetWebComponenet } from './core4svelte/web-components/RGConnectTarget.svelte';
+export { default as RGEditingNearNodeWidgetWebComponenet } from './core4svelte/web-components/RGEditingNearNodeWidget.svelte';
+export { default as RGEditingLineControllerWebComponenet } from './core4svelte/web-components/RGEditingLineController.svelte';
+export { default as RGEditingConnectControllerWebComponenet } from './core4svelte/web-components/RGEditingConnectController.svelte';
+export { default as RGEditingReferenceLineWebComponenet } from './core4svelte/web-components/RGEditingReferenceLine.svelte';
+export { default as RGWatermark } from './core4svelte/widgets/GraphWatermark.svelte';
+export { default as RGBackground } from './core4svelte/widgets/GraphBackground.svelte';
+export { default as RGEditingNearNodeWidget } from './core4svelte/editing/RGEditingNearNodeWidget.svelte';
+export { default as RGEditingLineController } from './core4svelte/editing/RGEditingLineController.svelte';
+export { default as RGEditingConnectController } from './core4svelte/editing/RGEditingConnectController.svelte';
+export { default as RGConnectSource } from './core4svelte/editing/RGConnectSource.svelte';
+export { default as RGConnectTarget } from './core4svelte/editing/RGConnectTarget.svelte';
+export { default as RGEditingConnectPoints } from './core4svelte/editing/RGEditingConnectPoints.svelte';
+export { default as RGEditingReferenceLine } from './core4svelte/editing/RGEditingReferenceLine.svelte';
+export { default as RelationLinker } from './core4svelte/RelationLinker.svelte';
+export { default as RGProvider } from './RGProvider.svelte';
+import * as RGOptionsDataUtils from "../../../relation-graph-models/data/RGOptionsDataUtils";
+import * as RGLineDataUtils from "../../../relation-graph-models/data/RGLineDataUtils";
+import * as RGNodeDataUtils from "../../../relation-graph-models/data/RGNodeDataUtils";
+export * from '../../../types';
+export * from './types-svelte';
+export declare const version: string;
+export declare const RelationGraphCore: typeof _RelationGraphCore;
+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('../../../relation-graph-models/utils/RGGraphMath').CreateJunctionPointParams): {
+            x: number;
+            y: number;
+        };
+        getRectHJoinPoint(params: import('../../../relation-graph-models/utils/RGGraphMath').CreateJunctionPointParams): {
+            x: number;
+            y: number;
+        };
+        getRectLeftJoinPoint(params: import('../../../relation-graph-models/utils/RGGraphMath').CreateJunctionPointParams): {
+            x: number;
+            y: number;
+        };
+        getRectRightJoinPoint(params: import('../../../relation-graph-models/utils/RGGraphMath').CreateJunctionPointParams): {
+            x: number;
+            y: number;
+        };
+        getRectTopJoinPoint(params: import('../../../relation-graph-models/utils/RGGraphMath').CreateJunctionPointParams): {
+            x: number;
+            y: number;
+        };
+        getRectBottomJoinPoint(params: import('../../../relation-graph-models/utils/RGGraphMath').CreateJunctionPointParams): {
+            x: number;
+            y: number;
+        };
+        getRectHorizontalLineJoinPoint(params: import('../../../relation-graph-models/utils/RGGraphMath').CreateJunctionPointParams): {
+            y: number;
+            x: number;
+        };
+        getRectVerticalLineLineJoinPoint(params: import('../../../relation-graph-models/utils/RGGraphMath').CreateJunctionPointParams): {
+            x: number;
+            y: number;
+        };
+        getRectVJoinPoint(params: import('../../../relation-graph-models/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('../../../relation-graph-models/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('.').RGNode, collectList?: import('.').RGNode[]): import('.').RGNode[];
+        isVisibleNode(thisNode: import('.').RGNode, deep?: number): boolean;
+        isAllowShowNode(thisNode: import('.').RGNode, deep?: number): boolean;
+        getNodeWidth(thisNode: import('.').RGNode): number;
+        getNodeHeight(thisNode: import('.').RGNode): number;
+        getNodeXByLotX(nodeAlignOption: {
+            alignItemsX: "start" | "center" | "end";
+        }, thisNode: import('.').RGNode): number;
+        getNodeYByLotY(nodeAlignOption: {
+            alignItemsY: "start" | "center" | "end";
+        }, thisNode: import('.').RGNode): number;
+        getNodeLotXY(nodeAlignOption: import('.').RGLayoutOptions4Alignment, node: import('.').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('.').JsonNode[], parentNode: import('.').JsonNode | null, nodesCollect: import('.').JsonNode[], linksCollect: import('.').JsonLine[]): void;
+    };
+    RGEffectUtils: {
+        startDrag(e: MouseEvent | TouchEvent, startPositionOrModel: import('.').RGCoordinate, onDragged: import('../../../relation-graph-models/utils/RGDragUtils').RGDraggedCallback, onDragging?: import('../../../relation-graph-models/utils/RGDragUtils').RGDraggingCallback): void;
+        onNodeMove(e: MouseEvent | TouchEvent): void;
+        onNodeDragend(e: MouseEvent | TouchEvent): void;
+    };
+};
+export { useRelationGraph } from './hooks/useRelationGraph';
+export declare const RGHooks: {
+    useGraphInstance: typeof import('./hooks/useGraphInstance').useGraphInstance;
+    useGraphStore: typeof import('./hooks/useGraphStore').useGraphStore;
+    useCreatingLine: typeof import('./hooks/useGraphStore').useCreatingLine;
+    useCreatingNode: typeof import('./hooks/useGraphStore').useCreatingNode;
+    useEditingNodes: typeof import('./hooks/useGraphStore').useEditingNodes;
+    useEditingLine: typeof import('./hooks/useGraphStore').useEditingLine;
+    useViewInformation: typeof import('./hooks/useGraphStore').useViewInformation;
+    useSelection: typeof import('./hooks/useGraphStore').useSelection;
+    useConnectingNode: typeof import('./hooks/useGraphStore').useConnectingNode;
+    useCheckedItem: typeof import('./hooks/useGraphStore').useCheckedItem;
+};
+export declare const useGraphInstance: typeof import('./hooks/useGraphInstance').useGraphInstance;
+export declare const RelationGraph: typeof _RelationGraph;
+export default _RelationGraph;

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

@@ -0,0 +1,85 @@
+import { JsonLine, JsonNode, RelationGraphInstance, RGCheckedItem, RGConnectingNode, RGCoordinate, RGCreatingLine, RGCreatingNode, RGEditingLine, RGEditingNodes, RGEventTargetType, RGFakeLine, RGLine, RGLineTarget, RGLink, RGNode, RGOptionsFull, RGPosition, RGSelectionView, RGUserEvent, RGViewInformation } from '../../../types';
+import { Readable, Writable } from 'svelte/store';
+export type RelationGraphEvents = {
+    onReady: CustomEvent<[RelationGraphInstance]>;
+    onNodeClick: CustomEvent<[RGNode, RGUserEvent]>;
+    onNodeExpand: CustomEvent<[RGNode, RGUserEvent]>;
+    onNodeCollapse: CustomEvent<[RGNode, RGUserEvent]>;
+    onLineClick: CustomEvent<[RGLine, RGLink, RGUserEvent]>;
+    onNodeDragStart: CustomEvent<[RGNode, RGUserEvent]>;
+    onNodeDragEnd: CustomEvent<[RGNode, RGUserEvent, number, number]>;
+    onNodeDragging: CustomEvent<[RGNode, number, number, number, number, RGUserEvent]>;
+    onCanvasDragEnd: CustomEvent<[RGUserEvent]>;
+    onCanvasDragging: CustomEvent<[number, number, number, number]>;
+    onContextmenu: CustomEvent<[RGUserEvent, RGEventTargetType, RGNode | RGLine | undefined, RGCoordinate, RGCoordinate]>;
+    onFullscreen: CustomEvent<[boolean, () => Promise<void>]>;
+    onCanvasClick: CustomEvent<[RGUserEvent]>;
+    onCanvasSelectionEnd: CustomEvent<[RGSelectionView, RGUserEvent]>;
+    beforeZoomStart: CustomEvent<[]>;
+    onZoomEnd: CustomEvent<[]>;
+    onViewResize: CustomEvent<[]>;
+    onResizeStart: CustomEvent<[RGNode[], RGUserEvent]>;
+    beforeNodeResize: CustomEvent<[RGNode, number, number, number, number]>;
+    onResizeEnd: CustomEvent<[RGNode[], number, number, RGUserEvent]>;
+    onLineVertexDropped: CustomEvent<[{
+        newLineTemplate: JsonLine;
+        fromNode: RGLineTarget | RGNode;
+        toNode: RGLineTarget | RGNode;
+    }]>;
+    beforeCreateLine: CustomEvent<[{
+        lineJson: JsonLine;
+        fromNode: RGLineTarget | RGNode;
+        toNode: RGLineTarget | RGNode;
+    }]>;
+    onLineBeCreated: CustomEvent<[{
+        lineJson: JsonLine;
+        fromNode: RGLineTarget | RGNode;
+        toNode: RGLineTarget | RGNode;
+    }]>;
+    beforeAddNodes: CustomEvent<[JsonNode[]]>;
+    beforeAddLines: CustomEvent<[JsonLine[]]>;
+    onKeyboardDown: CustomEvent<[KeyboardEvent]>;
+    onKeyboardUp: CustomEvent<[KeyboardEvent]>;
+    onCanvasDragStart: CustomEvent<[RGPosition, RGPosition, RGUserEvent]>;
+    onForceLayoutFinish: CustomEvent<[]>;
+    beforeScrollStart: CustomEvent<[number, number, Event]>;
+};
+export type RGEditingLineControllerEvents = {
+    onLinePathChanged: {
+        line: RGLine;
+        params: any;
+    };
+    onMoveLineVertexStart: {
+        type: 'start' | 'end';
+        line: RGLine;
+    };
+    onMoveLineVertexEnd: {
+        from: RGNode | RGLineTarget | RGPosition;
+        to: RGNode | RGLineTarget | RGPosition;
+        newLineJson?: JsonLine;
+    };
+    onLineTextDragEnd: {
+        line: RGLine;
+    };
+    onLineTextChanged: {
+        line: RGLine;
+    };
+};
+export type RGDataStore = {
+    optionsStore: Writable<RGOptionsFull>;
+    shouldRenderNodesStore: Writable<RGNode[]>;
+    shouldRenderLinesStore: Writable<RGLine[]>;
+    shouldRenderFakeLinesStore: Writable<RGFakeLine[]>;
+};
+export type RGSvelteHooksStore = {
+    creatingLineStore: Readable<RGCreatingLine>;
+    creatingNodeStore: Readable<RGCreatingNode>;
+    editingNodesStore: Readable<RGEditingNodes>;
+    editingLineStore: Readable<RGEditingLine>;
+    connectingNodeStore: Readable<RGConnectingNode>;
+    viewInformationStore: Readable<RGViewInformation>;
+    selectionStore: Readable<RGSelectionView & {
+        show: boolean;
+    }>;
+    checkedItemStore: Readable<RGCheckedItem>;
+};

package/types/packages/platforms/vue2/src/core4vue/RGCanvas.vue.d.ts

@@ -1,11 +1,7 @@
 declare const _default: import('vue').DefineComponent<Readonly<{}>, {}, {}, {
+    graphInstance(): any;
     options(): any;
-    canvasSizeAndPosition(): {
-        width: string;
-        height: string;
-        'background-color': string;
-        transform: string;
-    };
+    canvasSizeAndPosition(): any;
 }, {
     onDragStart(e: any): void;
     contextmenu(e: any): void;

package/types/packages/platforms/vue2/src/core4vue/RGCanvasContent.vue.d.ts

@@ -1,10 +1,10 @@
-declare const _default: import('vue').DefineComponent<Readonly<{}>, {}, {}, {
+declare const _default: import('vue').DefineComponent<string[], {}, {}, {
+    graphInstance(): any;
     options(): any;
-    allNodeConfigList(): any;
-    allFakeLineConfigList(): any;
-    allLineConfigList(): any;
-    creatingLineConfig(): any;
+    graphInstanceId(): any;
 }, {
     init(): void;
-}, import('vue/types/v3-component-options').ComponentOptionsMixin, import('vue/types/v3-component-options').ComponentOptionsMixin, {}, string, Readonly<import('vue').ExtractPropTypes<Readonly<{}>>>, {}>;
+}, import('vue/types/v3-component-options').ComponentOptionsMixin, import('vue/types/v3-component-options').ComponentOptionsMixin, {}, string, Readonly<import('vue').ExtractPropTypes<string[]>>, {
+    [x: number]: string;
+}>;
 export default _default;

package/types/packages/platforms/vue2/src/core4vue/RGCanvasContent4CreatingLine.vue.d.ts

@@ -0,0 +1,9 @@
+declare const _default: import('vue').DefineComponent<string[], {}, {}, {
+    graphInstance(): any;
+    creatingLineConfig(): any;
+}, {
+    init(): void;
+}, import('vue/types/v3-component-options').ComponentOptionsMixin, import('vue/types/v3-component-options').ComponentOptionsMixin, {}, string, Readonly<import('vue').ExtractPropTypes<string[]>>, {
+    [x: number]: string;
+}>;
+export default _default;

package/types/packages/platforms/vue2/src/core4vue/RGCanvasContent4FakeLines.vue.d.ts

@@ -0,0 +1,9 @@
+declare const _default: import('vue').DefineComponent<string[], {}, {}, {
+    graphInstance(): any;
+    allFakeLineConfigList(): any;
+}, {
+    init(): void;
+}, import('vue/types/v3-component-options').ComponentOptionsMixin, import('vue/types/v3-component-options').ComponentOptionsMixin, {}, string, Readonly<import('vue').ExtractPropTypes<string[]>>, {
+    [x: number]: string;
+}>;
+export default _default;

package/types/packages/platforms/vue2/src/core4vue/RGCanvasContent4Lines.vue.d.ts

@@ -0,0 +1,9 @@
+declare const _default: import('vue').DefineComponent<string[], {}, {}, {
+    graphInstance(): any;
+    allLineConfigList(): any;
+}, {
+    init(): void;
+}, import('vue/types/v3-component-options').ComponentOptionsMixin, import('vue/types/v3-component-options').ComponentOptionsMixin, {}, string, Readonly<import('vue').ExtractPropTypes<string[]>>, {
+    [x: number]: string;
+}>;
+export default _default;

package/types/packages/platforms/vue2/src/core4vue/RGCanvasContent4Nodes.vue.d.ts

@@ -0,0 +1,9 @@
+declare const _default: import('vue').DefineComponent<string[], {}, {}, {
+    graphInstance(): any;
+    allNodeConfigList(): any;
+}, {
+    init(): void;
+}, import('vue/types/v3-component-options').ComponentOptionsMixin, import('vue/types/v3-component-options').ComponentOptionsMixin, {}, string, Readonly<import('vue').ExtractPropTypes<string[]>>, {
+    [x: number]: string;
+}>;
+export default _default;

package/types/packages/platforms/vue2/src/core4vue/RGEasyView.vue.d.ts

@@ -1,4 +1,5 @@
 declare const _default: import('vue').DefineComponent<Readonly<{}>, {}, {}, {
+    graphInstance(): any;
     options(): any;
 }, {
     init(): void;

package/types/packages/platforms/vue2/src/core4vue/RGGraphDefs.vue.d.ts

@@ -5,6 +5,7 @@ declare const _default: import('vue').DefineComponent<{
         default: boolean;
     };
 }, {}, {}, {
+    graphInstance(): any;
     options(): any;
 }, {}, import('vue/types/v3-component-options').ComponentOptionsMixin, import('vue/types/v3-component-options').ComponentOptionsMixin, {}, string, Readonly<import('vue').ExtractPropTypes<{
     forElementLines: {

package/types/packages/platforms/vue2/src/core4vue/RGLineContent.vue.d.ts

@@ -1,22 +1,22 @@
-declare const _default: import('vue').DefineComponent<{
-    lineConfig: {
-        mustUseProp: boolean;
-        default: () => {};
-        type: ObjectConstructor;
-    };
-}, {}, {}, {
-    options(): any;
+declare const _default: import('vue').DefineComponent<Readonly<{
+    lineUseTextPath?: any;
+    lineConfig?: any;
+    graphInstanceId?: any;
+    checked?: any;
+}>, {}, {}, {
+    graphInstance(): any;
     useTextPath(): any;
     linePathInfo(): any;
-}, {
-    onLineClick(e: any): void;
-}, import('vue/types/v3-component-options').ComponentOptionsMixin, import('vue/types/v3-component-options').ComponentOptionsMixin, {}, string, Readonly<import('vue').ExtractPropTypes<{
-    lineConfig: {
-        mustUseProp: boolean;
-        default: () => {};
-        type: ObjectConstructor;
-    };
-}>>, {
-    lineConfig: Record<string, any>;
+    textStyle(): any;
+}, {}, import('vue/types/v3-component-options').ComponentOptionsMixin, import('vue/types/v3-component-options').ComponentOptionsMixin, {}, string, Readonly<import('vue').ExtractPropTypes<Readonly<{
+    lineUseTextPath?: any;
+    lineConfig?: any;
+    graphInstanceId?: any;
+    checked?: any;
+}>>>, {
+    readonly lineUseTextPath?: any;
+    readonly lineConfig?: any;
+    readonly graphInstanceId?: any;
+    readonly checked?: any;
 }>;
 export default _default;

package/types/packages/platforms/vue2/src/core4vue/RGLinePath.vue.d.ts

@@ -1,19 +1,7 @@
-declare const _default: import('vue').DefineComponent<{
-    lineConfig: {
-        mustUseProp: boolean;
-        default: () => {};
-        type: ObjectConstructor;
-    };
-    linePathInfo: {
-        mustUseProp: boolean;
-        default: () => {};
-        type: ObjectConstructor;
-    };
-}, {}, {}, {
-    options(): any;
+declare const _default: import('vue').DefineComponent<string[], {}, {}, {
+    graphInstance(): any;
     pathId(): string;
     useTextPath(): any;
-    checked(): boolean;
     line(): any;
     lineWidth(): string | undefined;
     startArrowMarkerId(): any;
@@ -21,19 +9,7 @@ declare const _default: import('vue').DefineComponent<{
     textStyle(): any;
 }, {
     onLineClick(e: any): void;
-}, import('vue/types/v3-component-options').ComponentOptionsMixin, import('vue/types/v3-component-options').ComponentOptionsMixin, {}, string, Readonly<import('vue').ExtractPropTypes<{
-    lineConfig: {
-        mustUseProp: boolean;
-        default: () => {};
-        type: ObjectConstructor;
-    };
-    linePathInfo: {
-        mustUseProp: boolean;
-        default: () => {};
-        type: ObjectConstructor;
-    };
-}>>, {
-    lineConfig: Record<string, any>;
-    linePathInfo: Record<string, any>;
+}, import('vue/types/v3-component-options').ComponentOptionsMixin, import('vue/types/v3-component-options').ComponentOptionsMixin, {}, string, Readonly<import('vue').ExtractPropTypes<string[]>>, {
+    [x: number]: string;
 }>;
 export default _default;

package/types/packages/platforms/vue2/src/core4vue/RGLinePeel.vue.d.ts

@@ -1,20 +1,9 @@
-declare const _default: import('vue').DefineComponent<{
-    line: {
-        mustUseProp: boolean;
-        default: () => {};
-        type: ObjectConstructor;
-    };
-}, {}, {}, {
+declare const _default: import('vue').DefineComponent<string[], {}, {}, {
+    graphInstance(): any;
     config(): any;
 }, {
     onLineClick(e: any): void;
-}, import('vue/types/v3-component-options').ComponentOptionsMixin, import('vue/types/v3-component-options').ComponentOptionsMixin, {}, string, Readonly<import('vue').ExtractPropTypes<{
-    line: {
-        mustUseProp: boolean;
-        default: () => {};
-        type: ObjectConstructor;
-    };
-}>>, {
-    line: Record<string, any>;
+}, import('vue/types/v3-component-options').ComponentOptionsMixin, import('vue/types/v3-component-options').ComponentOptionsMixin, {}, string, Readonly<import('vue').ExtractPropTypes<string[]>>, {
+    [x: number]: string;
 }>;
 export default _default;

package/types/packages/platforms/vue2/src/core4vue/RGNodeExpandHolder.vue.d.ts

@@ -3,10 +3,6 @@ declare const _default: import('vue').DefineComponent<{
         type: ObjectConstructor;
         required: true;
     };
-    expandButtonClass: {
-        type: StringConstructor;
-        required: true;
-    };
     expandOrCollapseNode: {
         type: FunctionConstructor;
         required: true;
@@ -15,15 +11,13 @@ declare const _default: import('vue').DefineComponent<{
         type: StringConstructor;
         required: true;
     };
-}, {}, {}, {}, {}, import('vue/types/v3-component-options').ComponentOptionsMixin, import('vue/types/v3-component-options').ComponentOptionsMixin, {}, string, Readonly<import('vue').ExtractPropTypes<{
+}, {}, {}, {
+    expandButtonClass(): "c-expanded" | "c-collapsed";
+}, {}, import('vue/types/v3-component-options').ComponentOptionsMixin, import('vue/types/v3-component-options').ComponentOptionsMixin, {}, string, Readonly<import('vue').ExtractPropTypes<{
     node: {
         type: ObjectConstructor;
         required: true;
     };
-    expandButtonClass: {
-        type: StringConstructor;
-        required: true;
-    };
     expandOrCollapseNode: {
         type: FunctionConstructor;
         required: true;

package/types/packages/platforms/vue2/src/core4vue/RGNodePeel.vue.d.ts

@@ -1,32 +1,17 @@
-declare const _default: import('vue').DefineComponent<{
-    nodeProps: {
-        mustUseProp: boolean;
-        default: () => {};
-        type: ObjectConstructor;
-    };
-}, {}, {
+declare const _default: import('vue').DefineComponent<string[], {}, {
     expanding: boolean;
 }, {
-    oldVersionSlot(): import('vue/types/vnode').ScopedSlotChildren | null;
-    expandButtonClass(): "c-expanded" | "c-collapsed";
+    graphInstance(): any;
     showExpandHolder(): boolean | undefined;
-    options(): any;
     borderColor(): any;
     borderWidth(): string | undefined;
     nodeWidth(): string | undefined;
     nodeHeight(): string | undefined;
-    isVisibleNode(): boolean;
+    isVisibleNode(): any;
 }, {
     expandOrCollapseNode(e: any): Promise<void>;
     onDragStart(e: any): void;
-    onclick(e: any): void;
-}, import('vue/types/v3-component-options').ComponentOptionsMixin, import('vue/types/v3-component-options').ComponentOptionsMixin, {}, string, Readonly<import('vue').ExtractPropTypes<{
-    nodeProps: {
-        mustUseProp: boolean;
-        default: () => {};
-        type: ObjectConstructor;
-    };
-}>>, {
-    nodeProps: Record<string, any>;
+}, import('vue/types/v3-component-options').ComponentOptionsMixin, import('vue/types/v3-component-options').ComponentOptionsMixin, {}, string, Readonly<import('vue').ExtractPropTypes<string[]>>, {
+    [x: number]: string;
 }>;
 export default _default;

package/types/packages/platforms/vue2/src/core4vue/RGProvider.vue.d.ts

@@ -0,0 +1,50 @@
+declare const _default: import('vue').DefineComponent<{
+    relationGraphCore: {
+        mustUseProp: boolean;
+        default: null;
+        type: FunctionConstructor;
+    };
+    forLinker: {
+        mustUseProp: boolean;
+        default: boolean;
+        type: BooleanConstructor;
+    };
+}, {}, {
+    graphData: {
+        rootNode: null;
+        nodes: never[];
+        normalLines: never[];
+        fakeLines: never[];
+    };
+    runtimeData: {
+        runtimeDATA4Links: never[];
+        runtimeDATA4ElLineTargets: never[];
+        runtimeDATA4ConnectTargets: never[];
+        runtimeDATA4NodeMap: Map<any, any>;
+        runtimeDATA4LinkMap: Map<any, any>;
+        runtimeDATA4ShouldRenderItems: {
+            nodes: never[];
+            lines: never[];
+            fakeLines: never[];
+        };
+    };
+    graphStore: {
+        options: import('packages/types').RGOptionsFull;
+        graphInstance: null;
+    };
+}, {}, {}, import('vue/types/v3-component-options').ComponentOptionsMixin, import('vue/types/v3-component-options').ComponentOptionsMixin, {}, string, Readonly<import('vue').ExtractPropTypes<{
+    relationGraphCore: {
+        mustUseProp: boolean;
+        default: null;
+        type: FunctionConstructor;
+    };
+    forLinker: {
+        mustUseProp: boolean;
+        default: boolean;
+        type: BooleanConstructor;
+    };
+}>>, {
+    relationGraphCore: Function;
+    forLinker: boolean;
+}>;
+export default _default;