@relation-graph/vue3 3.0.4

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

@@ -0,0 +1,131 @@
+export type SizeInfo = {
+    canvas_width: number;
+    canvas_height: number;
+    node_width: number;
+    node_height: number;
+};
+export type CreateJunctionPointParams = {
+    from_x: number;
+    from_y: number;
+    to_x: number;
+    to_y: number;
+    f_W: number;
+    f_H: number;
+    t_W: number;
+    t_H: number;
+    nodeShape: number;
+    isReverse?: boolean;
+    isEndPoint: boolean;
+    totalLinesBetweenNodes?: number;
+    currentLineIndex?: number;
+    lineDistance?: number;
+};
+export declare const 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: CreateJunctionPointParams): {
+        x: number;
+        y: number;
+    };
+    getRectHJoinPoint(params: CreateJunctionPointParams): {
+        x: number;
+        y: number;
+    };
+    getRectLeftJoinPoint(params: CreateJunctionPointParams): {
+        x: number;
+        y: number;
+    };
+    getRectRightJoinPoint(params: CreateJunctionPointParams): {
+        x: number;
+        y: number;
+    };
+    getRectTopJoinPoint(params: CreateJunctionPointParams): {
+        x: number;
+        y: number;
+    };
+    getRectBottomJoinPoint(params: CreateJunctionPointParams): {
+        x: number;
+        y: number;
+    };
+    getRectHorizontalLineJoinPoint(params: CreateJunctionPointParams): {
+        y: number;
+        x: number;
+    };
+    getRectVerticalLineLineJoinPoint(params: CreateJunctionPointParams): {
+        x: number;
+        y: number;
+    };
+    getRectVJoinPoint(params: 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: 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;
+    };
+    /**
+     * 获取点x,y以 c_x,c_y为中心旋转rotateDeg后的新坐标
+     * @param c_x
+     * @param c_y
+     * @param x
+     * @param y
+     * @param rotateDeg 旋转角度，取值范围 0 - 360
+     */
+    getRotatedPoint(x: number, y: number, c_x: number, c_y: number, rotateDeg: number): {
+        x: number;
+        y: number;
+    };
+    /**
+     * Returns the new x coordinate representing the point x after being horizontally flipped around the center point c_x
+     * @param x
+     * @param c_x
+     */
+    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;
+    /**
+     * 获取一个文字旋转的角度,以便看起来是沿着线条的角度排版，但又要确保文字是从左向右展示的
+     * @param fx
+     * @param fy
+     * @param tx
+     * @param ty
+     */
+    getTextAngle(fx: number, fy: number, tx: number, ty: number): number;
+};
+export declare const getNodeDistance: (fx: number, fy: number, tx: number, ty: number) => number;
+export declare function rgSimpleGridLayout<ItemType extends {
+    width: number;
+    height: number;
+}>(columns: number, gap: number, items: ItemType[], eachFn: (item: ItemType, x: number, y: number) => void, startX?: number, startY?: number): void;
+export default RGGraphMath;

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

@@ -0,0 +1,41 @@
+export declare const RGIconsData: {
+    'icon-quanping': {
+        data: string;
+    };
+    'icon-fangda': {
+        data: string;
+    };
+    'icon-suoxiao': {
+        data: string;
+    };
+    'icon-zidong': {
+        data: string;
+    };
+    'icon-yuanquanfenxiang': {
+        data: string;
+    };
+    'icon-hj2': {
+        data: string;
+    };
+    'icon-lianjie_connecting5': {
+        data: string;
+    };
+    'icon-ico_reset': {
+        data: string;
+    };
+    'icon-lianjieliu': {
+        data: string;
+    };
+    'icon-resize-': {
+        data: string;
+    };
+    'icon-tupian': {
+        data: string;
+    };
+    'icon-ziyuan': {
+        data: string;
+    };
+    'icon-lianjiezhong': {
+        data: string;
+    };
+};

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

@@ -0,0 +1,45 @@
+import { RelationGraphProps } from '../../types';
+export declare const getEventListeners: (props: RelationGraphProps) => {
+    onReady: ((graphInstance: import('../models/RelationGraphCore').RelationGraphCore) => void) | undefined;
+    onNodeClick: ((node: import('../../types').RGNode, e: import('../../types').RGUserEvent) => boolean | void | Promise<boolean | void>) | undefined;
+    onNodeExpand: ((node: import('../../types').RGNode, e: import('../../types').RGUserEvent) => boolean | void | Promise<boolean | void>) | undefined;
+    onNodeCollapse: ((node: import('../../types').RGNode, e: import('../../types').RGUserEvent) => boolean | void | Promise<boolean | void>) | undefined;
+    onLineClick: ((line: import('../../types').RGLine, link: import('../../types').RGLink, e: import('../../types').RGUserEvent) => boolean | void | Promise<boolean | void>) | undefined;
+    onNodeDragStart: ((node: import('../../types').RGNode, e: import('../../types').RGUserEvent) => void) | undefined;
+    onNodeDragEnd: ((node: import('../../types').RGNode, e: import('../../types').RGUserEvent, x_buff: number, y_buff: number) => void) | undefined;
+    onNodeDragging: ((node: import('../../types').RGNode, newX: number, newY: number, buffX: number, buffY: number, e: import('../../types').RGUserEvent) => void | import('../../types').RGCoordinate | undefined) | undefined;
+    onCanvasDragEnd: ((e: import('../../types').RGUserEvent) => void) | undefined;
+    onCanvasDragging: ((newX: number, newY: number, buffX: number, buffY: number) => void | import('../../types').RGCoordinate | undefined) | undefined;
+    onContextmenu: ((e: import('../../types').RGUserEvent, objectType: import('../../types').RGEventTargetType, object: import('../../types').RGNode | import('../../types').RGLine | undefined, eventPositionOnCanvas: import('../../types').RGCoordinate, eventPositionOnView: import('../../types').RGCoordinate) => void) | undefined;
+    onFullscreen: ((newValue: boolean, defaultFullscreen: () => Promise<void>) => void) | undefined;
+    onCanvasClick: ((e: import('../../types').RGUserEvent) => void) | undefined;
+    onCanvasSelectionEnd: ((selectionView: import('../../types').RGSelectionView, e: import('../../types').RGUserEvent) => void) | undefined;
+    beforeZoomStart: (() => false | void) | undefined;
+    onZoomEnd: (() => void) | undefined;
+    onViewResize: (() => void) | undefined;
+    onResizeStart: ((nodes: import('../../types').RGNode[], e: import('../../types').RGUserEvent) => void) | undefined;
+    beforeNodeResize: ((node: import('../../types').RGNode, newX: number, newY: number, newW: number, newH: number) => false | void) | undefined;
+    onResizeEnd: ((nodes: import('../../types').RGNode[], buffX: number, buffY: number, e: import('../../types').RGUserEvent) => void) | undefined;
+    onLineVertexDropped: ((lineInfo: {
+        newLineTemplate: import('../../types').JsonLine;
+        fromNode: import('../../types').RGNode | import('../../types').RGLineTarget;
+        toNode: import('../../types').RGNode | import('../../types').RGLineTarget;
+    }) => void) | undefined;
+    beforeCreateLine: ((lineInfo: {
+        lineJson: import('../../types').JsonLine;
+        fromNode: import('../../types').RGNode | import('../../types').RGLineTarget;
+        toNode: import('../../types').RGNode | import('../../types').RGLineTarget;
+    }) => false | void) | undefined;
+    onLineBeCreated: ((lineInfo: {
+        lineJson: import('../../types').JsonLine;
+        fromNode: import('../../types').RGNode | import('../../types').RGLineTarget;
+        toNode: import('../../types').RGNode | import('../../types').RGLineTarget;
+    }) => void) | undefined;
+    beforeAddNodes: ((nodes: import('../../types').JsonNode[]) => void) | undefined;
+    beforeAddLines: ((lines: import('../../types').JsonLine[]) => void) | undefined;
+    onKeyboardDown: ((e: KeyboardEvent) => void) | undefined;
+    onKeyboardUp: ((e: KeyboardEvent) => void) | undefined;
+    onCanvasDragStart: ((canvasMoveStartPosition: import('../../types').RGCoordinate, eventClientStartPosition: import('../../types').RGCoordinate, e: import('../../types').RGUserEvent) => void) | undefined;
+    onForceLayoutFinish: (() => void) | undefined;
+    beforeScrollStart: ((buffX: number, buffY: number, e: Event) => true | void | undefined) | undefined;
+};

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

@@ -0,0 +1,29 @@
+import { JsonLine, JsonNode, RGLayoutOptions4Alignment, RGNode, RGNodeShape } from '../../types';
+export declare const RGNodesAnalytic: {
+    getDescendantNodes(node: RGNode, collectList?: RGNode[]): RGNode[];
+    isVisibleNode(thisNode: RGNode, deep?: number): boolean;
+    isAllowShowNode(thisNode: RGNode, deep?: number): boolean;
+    getNodeWidth(thisNode: RGNode): number;
+    getNodeHeight(thisNode: RGNode): number;
+    getNodeXByLotX(nodeAlignOption: {
+        alignItemsX: 'start' | 'center' | 'end';
+    }, thisNode: RGNode): number;
+    getNodeYByLotY(nodeAlignOption: {
+        alignItemsY: 'start' | 'center' | 'end';
+    }, thisNode: RGNode): number;
+    getNodeLotXY(nodeAlignOption: RGLayoutOptions4Alignment, node: 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: JsonNode[], parentNode: JsonNode | null, nodesCollect: JsonNode[], linksCollect: JsonLine[]): void;
+};
+export declare const getNodeShape: (nodeShape: RGNodeShape, defaultNodeShape: RGNodeShape) => RGNodeShape;
+export default RGNodesAnalytic;

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

@@ -0,0 +1,7 @@
+export declare const RGTips: {
+    Vue3GetInstance: string;
+    ReactGetInstance: string;
+    Vue2GetInstance: string;
+    setJsonData: string;
+    setJsonData4Vue2: string;
+};

package/types/packages/relation-graph-models/utils/line/RGLinePath.d.ts

@@ -0,0 +1,105 @@
+import { RGCoordinate, RGCtrlPointForLine44 } from '../../../types';
+interface MoveToCommandAbsolute {
+    type: 'M';
+    x: number;
+    y: number;
+}
+interface LineToCommandRelative {
+    type: 'l';
+    dx: number;
+    dy: number;
+}
+interface LineToCommand {
+    type: 'L';
+    x: number;
+    y: number;
+}
+interface HorizontalLineToCommandRelative {
+    type: 'h';
+    dx: number;
+}
+interface VerticalLineToCommandRelative {
+    type: 'v';
+    dy: number;
+}
+interface CubicCurveToCommandRelative {
+    type: 'c';
+    dx1: number;
+    dy1: number;
+    dx2: number;
+    dy2: number;
+    dx: number;
+    dy: number;
+}
+interface SmoothCubicCurveToCommandRelative {
+    type: 's';
+    dx2: number;
+    dy2: number;
+    dx: number;
+    dy: number;
+}
+interface QuadraticCurveToCommandRelative {
+    type: 'q';
+    dx1: number;
+    dy1: number;
+    dx: number;
+    dy: number;
+}
+interface QuadraticCurveToCommand {
+    type: 'Q';
+    x1: number;
+    y1: number;
+    x: number;
+    y: number;
+}
+interface SmoothQuadraticCurveToCommandRelative {
+    type: 't';
+    dx: number;
+    dy: number;
+}
+interface ArcCommandRelative {
+    type: 'a';
+    rx: number;
+    ry: number;
+    xAxisRotation: number;
+    largeArcFlag: 0 | 1;
+    sweepFlag: 0 | 1;
+    dx: number;
+    dy: number;
+}
+interface ClosePathCommand {
+    type: 'Z';
+}
+export type PathCommand = MoveToCommandAbsolute | LineToCommandRelative | LineToCommand | HorizontalLineToCommandRelative | VerticalLineToCommandRelative | CubicCurveToCommandRelative | SmoothCubicCurveToCommandRelative | QuadraticCurveToCommandRelative | QuadraticCurveToCommand | SmoothQuadraticCurveToCommandRelative | ArcCommandRelative | ClosePathCommand;
+export type RGLinePathCommands = PathCommand[];
+/**
+ * 将特定场景的结构化路径命令数组转换为 SVG 路径 'd' 属性字符串。
+ * (M, Z 大写，其他命令小写)
+ * @param pathCommands PathCommandCustom 对象数组。
+ * @returns SVG 路径 'd' 字符串。
+ */
+export declare const structuredPathToSvgD: (pathCommands: RGLinePathCommands) => string;
+export type SvgPathPoints = {
+    startPoint: RGCoordinate;
+    ctrl1: RGCoordinate;
+    ctrl2: RGCoordinate;
+    endPoint: RGCoordinate;
+    lines: RGCoordinate[];
+};
+export declare const getPointsByPath: (svgPath: string) => SvgPathPoints;
+export declare const getPointValue: (currentX: number, xOrBuffX: string, isRelative: boolean) => number;
+/**
+ * 修改折线线条路径中点
+ * @param points points是折线（线条只允许横向或者纵向前行）线条路径中的所有点，第一个点是起点，最后一个点是终点。
+ * @param updatePointIndex updatePointIndex是当前正在被调整的线段，即表示points[updatePointIndex]到points[updatePointIndex + 1]之间的线段
+ * @param offsetX 鼠标被移动的x增量值，当updatePointIndex对应的先对是横线，则忽略此值的变动，因为横线只允许被上下调整
+ * @param offsetY 鼠标被移动的y增量值，当updatePointIndex对应的先对是纵线，则忽略此值的变动，因为纵线只允许被左右调整
+ * @return newPoints 返回调整后的折线路径中的所有点
+ */
+export declare const updateLinePoints: (points: RGCoordinate[], startPoints: RGCoordinate[], updatePointIndex: number, split: RGCtrlPointForLine44, cursor: {
+    indexOffset: number;
+}, orignOffsetX: number, orignOffsetY: number) => {
+    newPoints: RGCoordinate[];
+    pointsChanged: boolean;
+};
+export {};

package/types/packages/relation-graph-models/utils/line/RGLinePathUtils.d.ts

@@ -0,0 +1,54 @@
+import { RGCoordinate, RGJunctionPoint } from '../../../types';
+import { PathCommand } from './RGLinePath';
+export declare enum RGDirection {
+    Left = "left",
+    Top = "top",
+    Right = "right",
+    Bottom = "bottom"
+}
+export declare const handleDirections: {
+    [key: string]: RGCoordinate;
+};
+export declare function getPoints({ source, sourcePosition, target, targetPosition, center, sourceOffset, targetOffset }: {
+    source: RGCoordinate;
+    sourcePosition: RGDirection;
+    target: RGCoordinate;
+    targetPosition: RGDirection;
+    center: RGCoordinate;
+    sourceOffset: number;
+    targetOffset: number;
+}): [RGCoordinate[], number, number, number, number, number];
+export declare const getEasyPoints: ({ source, sourcePosition, target, targetPosition, center, sourceOffset, targetOffset }: {
+    source: RGCoordinate;
+    sourcePosition: RGDirection;
+    target: RGCoordinate;
+    targetPosition: RGDirection;
+    center: RGCoordinate;
+    sourceOffset: number;
+    targetOffset: number;
+}) => [RGCoordinate[], number, number, number, number, number];
+export declare const toIntPoints: (allPoints: RGCoordinate[]) => void;
+export declare const clearSamePoint: (allPoints: RGCoordinate[]) => any[];
+export declare function getBendCommands(a: RGCoordinate, b: RGCoordinate, c: RGCoordinate, radiusSize: number): PathCommand[];
+export declare const createPathCommandsByPoints: (points: RGCoordinate[], borderRadius: number) => PathCommand[];
+export declare enum LVLineJunctionPoint {
+    border = "border",
+    ltrb = "ltrb",
+    tb = "tb",
+    lr = "lr",
+    left = "left",
+    right = "right",
+    top = "top",
+    bottom = "bottom"
+}
+export declare const getJunctionPointDirection: (junctionPoint: RGJunctionPoint | undefined, x: number, y: number, isEnd: boolean, f_x: number, f_y: number, t_x: number, t_y: number) => RGDirection;
+export declare const getReverseJPDirection: (dir: RGDirection) => RGDirection;
+export declare const getJPDirectionByPoint: (point1: RGCoordinate, point2: RGCoordinate) => RGDirection;
+export type SvgPathPoints = {
+    startPoint: RGCoordinate;
+    ctrl1: RGCoordinate;
+    ctrl2: RGCoordinate;
+    endPoint: RGCoordinate;
+    lines: RGCoordinate[];
+};
+export declare const calculatePolylineCenter: (points: RGCoordinate[]) => RGCoordinate;

package/types/packages/relation-graph-models/utils/line/RGPathGeneratorFor1.d.ts

@@ -0,0 +1,2 @@
+import { RGGenerateLinePrams, RGLinePathInfo, RGLineTextPosition } from '../../../types';
+export declare const generateLineFor1: (linePathGenerateParmas: RGGenerateLinePrams, textPosition?: RGLineTextPosition) => RGLinePathInfo;

package/types/packages/relation-graph-models/utils/line/RGPathGeneratorFor4.d.ts

@@ -0,0 +1,2 @@
+import { RGGenerateLinePrams, RGLinePathInfo, RGLineTextPosition } from '../../../types';
+export declare const generateLineFor4: (linePathGenerateParmas: RGGenerateLinePrams, textPosition?: RGLineTextPosition, defaultOptions?: {}) => RGLinePathInfo;

package/types/packages/relation-graph-models/utils/line/RGPathGeneratorFor44.d.ts

@@ -0,0 +1,2 @@
+import { RGGenerateLinePrams, RGLinePathInfo, RGLineTextPosition } from '../../../types';
+export declare const generateLineFor44: (linePathGenerateParmas: RGGenerateLinePrams, textPosition?: RGLineTextPosition, defaultOptions?: {}) => RGLinePathInfo;

package/types/packages/relation-graph-models/utils/line/RGPathGeneratorFor49.d.ts

@@ -0,0 +1,2 @@
+import { RGGenerateLinePrams, RGLinePathInfo, RGLineTextPosition } from '../../../types';
+export declare const generateLineFor49: (linePathGenerateParmas: RGGenerateLinePrams, textPosition?: RGLineTextPosition, defaultOptions?: {}) => RGLinePathInfo;

package/types/packages/relation-graph-models/utils/line/RGPathGeneratorFor6.d.ts

@@ -0,0 +1,6 @@
+import { RGGenerateLinePrams, RGLinePathInfo, RGLineTextPosition, RGPosition } from '../../../types';
+export declare const generateLineForCurve6: (linePathGenerateParmas: RGGenerateLinePrams, textPosition?: RGLineTextPosition) => RGLinePathInfo;
+export declare const calcCurveLineCenter: (P0: RGPosition, P1: RGPosition, P2: RGPosition, P3: RGPosition, t?: number) => {
+    x: number;
+    y: number;
+};

package/types/packages/relation-graph-models/utils/line/RGPathGeneratorFor8.d.ts

@@ -0,0 +1,2 @@
+import { RGGenerateLinePrams, RGLinePathInfo, RGLineTextPosition } from '../../../types';
+export declare const generateLineFor8: (linePathGenerateParmas: RGGenerateLinePrams, textPosition?: RGLineTextPosition) => RGLinePathInfo;

package/types/packages/relation-graph-models/utils/line/RGPathGeneratorForCurve.d.ts

@@ -0,0 +1,2 @@
+import { RGGenerateLinePrams, RGLinePathInfo, RGLineTextPosition } from '../../../types';
+export declare const generateLineForCurve: (linePathGenerateParmas: RGGenerateLinePrams, textPosition?: RGLineTextPosition) => RGLinePathInfo;