@relation-graph/react 3.0.0

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

@@ -0,0 +1,398 @@
+import { JsonLine, JsonNode, RGConnectTarget4NodePoint, RGFakeLine, RGFakeLineTargetRender, RGGenerateLineConfig, RGGraphData, RGGraphReactiveData, RGJsonData, RGJunctionPoint, RGLine, RGLineTarget, RGLink, RGListeners, RGNode, RGRectTarget, RGOptions, RGPosition } from '../types';
+import { RelationGraphWith1Dom } from './RelationGraphWith1Dom';
+export declare class RelationGraphWith2Data extends RelationGraphWith1Dom {
+    /**
+     * All data managed in RelationGraph, including all nodes RGNode, all relationships RGLink, the current root node, and all element lines elementLines
+     */
+    graphData: RGGraphData;
+    runtimeDATA4Links: RGLink[];
+    runtimeDATA4NodeMap: Record<string, RGNode>;
+    runtimeDATA4ConnectTargets: RGConnectTarget4NodePoint[];
+    /**
+     * [Used internally by relation-graph] The reactive data object of the current RelationGraph component
+     */
+    reactiveData: RGGraphReactiveData;
+    constructor(options: RGOptions, listeners: RGListeners);
+    /**
+     * [Used internally by relation-graph] Set reactive data objects
+     * @param graphData
+     * @param reactiveData
+     */
+    setReactiveData4Vue2(graphData: RGGraphData, reactiveData: RGGraphReactiveData, runtimeData: any): void;
+    runtimeDATA4ShouldRenderGraphData: {
+        nodes: RGLineTarget[];
+        lines: RGLine[];
+    };
+    /**
+     * [Used internally by relation-graph] Set reactive data objects
+     * @param graphData
+     * @param reactiveData
+     */
+    setReactiveData4Vue3(graphData: RGGraphData, reactiveData: RGGraphReactiveData, runtimeData: any): void;
+    protected _setOptions(options: RGOptions): void;
+    protected _setJsonData(jsonData: RGJsonData, resetViewSize?: boolean): void;
+    /**
+     * Clear all data in RelationGraph, including nodes, lines, element lines, and the root node
+     */
+    clearGraph(): void;
+    clearFakeLines(): void;
+    clearElementLines(): void;
+    /**
+     * Generate a unique Node id relative to the current existing nodes
+     * @param idLength The minimum length of the id, default is 5
+     */
+    generateNewNodeId(idLength?: number): string;
+    /**
+     * 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;
+    protected prevAddNodeTimestamp: number;
+    /**
+     * Convert JsonNode to RGNode object and add it to the graph
+     * @param _nodes
+     * @protected
+     */
+    protected loadNodes(_nodes: JsonNode[]): void;
+    /**
+     * Convert JsonLine to RGLine object and add it to the graph
+     * @param _lines
+     * @protected
+     */
+    protected loadLines(_lines: JsonLine[]): void;
+    private updateLinks;
+    /**
+     * Expand tree-structured data into flattened data
+     * @param orign_nodes Tree-structured data, e.g., [{id:'a',children:[{id:'a-1'},{id:'a-1', children: [{id:'a-1-1'}]}]}]
+     * @param parentNode Please pass null
+     * @param nodes_collect All expanded nodes will be stored here
+     * @param lines_collect All expanded lines will be stored here
+     */
+    flatNodeData(orign_nodes: JsonNode[], parentNode: JsonNode | null, nodes_collect: JsonNode[], lines_collect: JsonLine[]): void;
+    protected loadGraphJsonData(jsonData: RGJsonData): void;
+    protected getLineArrow(_color: string | undefined, isStartArrow?: boolean, checked?: boolean): string;
+    /**
+     * Get all node objects
+     */
+    getNodes(): RGNode[];
+    getShouldRenderNodes(): RGNode[] | RGLineTarget[];
+    protected calcShouldRenderNodes(): RGNode[];
+    getShouldRenderLines(): RGLine[];
+    protected calcShouldRenderLines(): RGLine[];
+    private mutationObserver4Nodes?;
+    private mutationObserver4CanvasSlotBehind?;
+    private mutationObserver4CanvasSlotAbove?;
+    private canvasConnectTargetsMap;
+    private reinitMutationObservers;
+    protected destroyMutationObserver(): void;
+    private updateConnectTargetsOnCanvas;
+    /**
+     * 供外部调用，更新指定节点的连接点位置，不适用于高频次调用
+     * @param nodeId
+     */
+    updateConnectTargetsByNodeId(nodeId: string): void;
+    private updateConnectTargetsOnNode;
+    private updateConnectTargetList;
+    private updateConnectTargetOffset;
+    private _onConnectTargetMounted;
+    private nodeConnectTargetsMap;
+    private getNodeElByNodeId;
+    private getNodeElByChildrenTarget;
+    getConnectTargetById(targetId: string): RGConnectTarget4NodePoint | undefined;
+    registerConnectTarget(connectTargetEl: HTMLDivElement, targetId: string, targetType: string, junctionPoint: RGJunctionPoint, targetData?: {}): RGConnectTarget4NodePoint | undefined;
+    unregisterConnectTarget(targetId: string): void;
+    private fakeLineTargetRender;
+    setFakeLineTargetRender(fakeLineTargetRender: RGFakeLineTargetRender): void;
+    generateCreatingLineConfig(): RGGenerateLineConfig;
+    private getFakeLineTargetNode;
+    private runtimeDATA4ElLineTargets;
+    getFakeLineTarget(targetType: string, targetId: string, fakeLine: RGFakeLine): RGLineTarget | undefined;
+    generateLineConfig(line: RGLine): RGGenerateLineConfig | false;
+    generateFakeLineConfig(fakeLine: RGFakeLine): RGGenerateLineConfig | false;
+    getShouldRenderFakeLines(): RGFakeLine[];
+    /**
+     * Get all relationship objects, note that here Link is not a line.
+     * Line: The lines refer to the connections between nodes, and the graph will generate lines based on these lines.
+     * Relationship (Link): The graph will also generate a Link to summarize the associations between nodes based on the lines (there is only one Link between two directly related nodes, and all relationship lines (Line[]) between nodes will be placed in link.relations).
+     * You can traverse and get all lines like this:
+     * const allLines: RGLine[] = [];
+     * for (const link of graphInstance.getLinks()) {
+     *    allLines.push(link.line);
+     * }
+     * // The Line object has all the properties of JsonLine, you can change these properties. For example, change the color of all lines to red:
+     * for (const line of allLines) {
+     *    line.color = 'red';
+     * }
+     */
+    getLinks(): RGLink[];
+    getRelatedLinesByNode(node: RGNode): RGLine[];
+    getLinesBetweenNodes(nodes: RGNode[]): RGLine[];
+    /**
+     * Convert an RGNode object to a JSON-serializable object
+     * @param nodeJson: JsonNode
+     */
+    transRGNodeToJsonObject(node: RGNode): JsonNode;
+    /**
+     * Convert an RGLink object to a JSON-serializable object
+     * @param lines: JsonLine[]
+     */
+    transRGLinkToJsonObject(link: RGLink): JsonLine[];
+    /**
+     * Convert an RGLine object to a JSON-serializable object
+     * @param lineJson: JsonLine
+     */
+    transRGLineToJsonObject(line: RGLine): JsonLine;
+    /**
+     * Get all nodes and lines data in the current graph.
+     * @param graphJsonData: RGJsonData
+     */
+    getGraphJsonData(): RGJsonData;
+    /**
+     * Get the configuration information of the current graph
+     */
+    getGraphJsonOptions(): {};
+    /**
+     * Print the current graph configuration and JSON data to the console
+     */
+    printGraphJsonData(): void;
+    /**
+     * Get the node object by node id
+     * @param nodeId: RGNode
+     */
+    getNodeById(nodeId: string): RGNode | undefined;
+    /**
+     * Add node
+     * @param node: JsonNode
+     */
+    addNode(node: JsonNode): void;
+    /**
+     * Add multiple nodes
+     * @param nodes: JsonNode[]
+     */
+    addNodes(nodes: JsonNode[]): void;
+    /**
+     * Get the RGLink object by relationship id
+     * @param linkId: string
+     */
+    getLinkById(linkId: string): RGLink | undefined;
+    /**
+     * Get the RGLink object by line id
+     * @param line: RGLine
+     */
+    getLinkByLineId(lineId: string): RGLink | undefined;
+    /**
+     * Get the RGLink object by line
+     * @param line: RGLine
+     */
+    getLinkByLine(line: RGLine): RGLink | undefined;
+    /**
+     * Get the RGLine object by line id
+     * @param line: RGLine
+     */
+    getLineById(lineId: string): RGLine | undefined;
+    getLines(): RGLine[];
+    /**
+     * Add line
+     * @param line: JsonLine
+     */
+    addLine(line: JsonLine): void;
+    /**
+     * Add multiple lines
+     * @param lines: JsonLine[]
+     */
+    addLines(lines: JsonLine[]): void;
+    /**
+     * Remove the specified RGLine object
+     * @param line
+     */
+    removeLine(line: RGLine): void;
+    /**
+     * Remove the specified RGLine object by line id
+     * @param lineId
+     */
+    removeLineById(lineId: string): void;
+    /**
+     * Remove the RGLink object from the graph
+     * @param link
+     */
+    removeLink(link: RGLink): void;
+    /**
+     * Delete the Link object by its id, usually used to delete all lines and data relationships between two nodes
+     * @param linkId
+     */
+    removeLinkById(linkId: string): void;
+    getFakeLines(): RGFakeLine[];
+    /**
+     * Add multiple lines
+     * @param lines: JsonLine[]
+     */
+    addFakeLines(lines: RGFakeLine[]): void;
+    /**
+     * Remove the specified RGLine object
+     * @param line
+     */
+    removeFakeLine(line: RGFakeLine): void;
+    getFakeLineById(lineId: string): RGFakeLine | undefined;
+    /**
+     * Remove the specified RGLine object by line id
+     * @param lineId
+     */
+    removeFakeLineById(lineId: string): void;
+    /**
+     * Add multiple element lines
+     * @param lines: JsonLine[]
+     */
+    addElementLines(lines: JsonLine[]): void;
+    /**
+     * 根据元素连线id获取元素连线
+     * @param elLink: RGLink
+     */
+    getElementLineById(elLineId: string): RGFakeLine | undefined;
+    /**
+     * Get all element lines
+     */
+    getElementLines(): RGLine[];
+    /**
+     * Delete element line by element line id
+     * @param elementLineId: string Element line id
+     */
+    removeELementLineById(elementLineId: string): void;
+    private elLineUpdating;
+    /**
+     * Update the position information of all element lines
+     */
+    updateElementLines(): void;
+    private _updateElementLines;
+    private updateCanvasBoxInfo;
+    private updateElementTarget;
+    private _canvasBoxXY;
+    private _updateElementLinePosition;
+    getElementPosition(elementId: string): {
+        x: number;
+        y: number;
+    };
+    /**
+     * Remove a node from the graph
+     * @param nodeId
+     */
+    removeNodeById(nodeId: string): void;
+    /**
+     * Remove a node from the graph
+     * @param node
+     */
+    removeNode(node: RGNode): void;
+    getNodeRelatedNodes(node: RGNode): RGNode[];
+    getNodeRelatedNodes4From(node: RGNode): RGNode[];
+    getNodeRelatedNodes4To(node: RGNode): RGNode[];
+    private beforeNodeBeRemove;
+    /**
+     * Set the coordinates of a node. Generally, you do not need to call this method; you can directly modify the x and y properties of the node.
+     * @param node
+     * @param x
+     * @param y
+     */
+    setNodePosition(node: RGNode, x: number, y: number): void;
+    getGraphOffet(): {
+        offset_x: number;
+        offset_y: number;
+    };
+    /**
+     * Display the specified canvas coordinates in the center of the visible area
+     * @param x
+     * @param y
+     */
+    setCanvasCenter(x: number, y: number): void;
+    private canvasDragging;
+    /**
+     * Set the canvas offset, used when dragging the canvas
+     * @param x
+     * @param y
+     */
+    setCanvasOffset(x: number, y: number): void;
+    /**
+     * Oh my, this seems to be a duplicate method, it seems to have the same effect as the getGroupNodesByNode method
+     * @param node
+     * @param groupNodes
+     */
+    findGroupNodes(node: RGNode, groupNodes?: RGNode[]): RGNode[];
+    /**
+     * Get all nodes that have a direct or indirect relationship with a given node
+     * @param node
+     * @param groupNodes Used to collect the found nodes
+     * @return All nodes that have a direct or indirect relationship with the node, including the node itself
+     */
+    getGroupNodesByNode(node: RGNode, groupNodes?: RGNode[]): RGNode[];
+    getNetworkNodesByNode(node: RGNode, networkNodes?: RGNode[]): RGNode[];
+    getDescendantNodes(node: RGNode): RGNode[];
+    /**
+     * When the size of the parent element of the relation-graph component changes, you can call this method to recalculate the view size
+     * @param zoomTo100
+     * @protected
+     */
+    resetViewSize(zoomTo100?: boolean): void;
+    /**
+     * This is an internal method, generally not needed to be called
+     */
+    updateViewBoxInfo(): void;
+    /**
+     * Calculate the plane space information occupied by all nodes
+     * @param nodes Optional, if not specified, it will be calculated based on all nodes
+     */
+    protected getStuffSize(nodes?: (RGNode | RGRectTarget)[]): {
+        width: number;
+        height: number;
+        minX: number;
+        minY: number;
+        maxX: number;
+        maxY: number;
+    };
+    getNodesViewInfo(nodes?: (RGNode | RGRectTarget)[]): {
+        width: number;
+        height: number;
+        minX: number;
+        minY: number;
+        maxX: number;
+        maxY: number;
+    };
+    /**
+     * Get the center coordinates of the plane space occupied by the node collection
+     * @param nodes Optional, if not specified, it will be calculated based on all nodes
+     */
+    getNodesCenter(nodes?: (RGNode | RGRectTarget)[]): {
+        x: number;
+        y: number;
+    };
+    /**
+     * Print the current graph configuration information to the console
+     */
+    printOptions(): void;
+    /**
+     * Print all data of the current graph to the console
+     */
+    printData(): void;
+    /**
+     * Lock the graph component screen and display a piece of text
+     * @param graphLoadingText The text to display
+     */
+    loading(graphLoadingText?: string): void;
+    /**
+     * Clear the lock on the graph component screen
+     */
+    clearLoading(): void;
+    /**
+     * Recalculate all visible nodes
+     * @param force
+     */
+    updateShouldRenderGraphData(force?: boolean): void;
+    protected _updateShouldRenderGraphData(): void;
+    updateNodesVisibleProperty(): void;
+    setCanvasMoveMode(newValue: boolean): void;
+    defaultLineConnectEndHandler(from: RGNode | RGLineTarget, to: RGNode | RGLineTarget | RGPosition, newLine?: JsonLine): void;
+    /**
+     * 在线条的起点或者终点发生变化后，重新修正 isReverse，因为在开始拖动线条端点时，有可能会修改这个属性。这一步完成后才会触发 onLineBeCreated事件，在onLineBeCreated事件中可以无需考虑 isReverse属性，直接添加线条
+     * @param from
+     * @param to
+     * @param newLine
+     */
+    defaultLineVertexBeChangedHandler(from: RGNode, to: RGNode | RGPosition, newLine?: JsonLine): void;
+}

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

@@ -0,0 +1,20 @@
+import { RGListeners, RGOptions } from '../types';
+import { RelationGraphWith2Data } from './RelationGraphWith2Data';
+export declare class RelationGraphWith3Image extends RelationGraphWith2Data {
+    constructor(options: RGOptions, listeners: RGListeners);
+    private $watermarkDom;
+    private $watermarkPosition;
+    private $backgroundDom;
+    setWatermarkDom(watermarkDom: HTMLDivElement | null, forImage?: boolean, forDisplay?: boolean, position?: string): void;
+    setBackgroundDom(backgroundDom: HTMLDivElement | null, forImage?: boolean, forDisplay?: boolean): void;
+    dataURLToBlob(dataurl: string): Blob | undefined;
+    createGraphCanvas(format?: string): Promise<HTMLCanvasElement>;
+    private mergeCanvas;
+    private createGraphBackgroundCanvas;
+    private createGraphWatermarkCanvas;
+    private createGraphMainCanvas;
+    createImage(exportDom: HTMLDivElement, opts: any, format: string, fileName: string): Promise<any>;
+    getImageBase64(format?: string): Promise<void>;
+    downloadAsImage(format?: string, fileName?: string): Promise<void>;
+    downloadImageAsFile(canvas: HTMLCanvasElement, format: string, fileName: string): Promise<void>;
+}

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

@@ -0,0 +1,48 @@
+import { RelationGraphWith3Image } from './RelationGraphWith3Image';
+import { RGJunctionPoint, RGElementLine, RGGenerateLineConfig, RGGenerateLinePrams, RGLine, RGLinePathInfo, RGLineTextPosition, RGLink, RGListeners, RGOptions, RGUserEvent } from '../types';
+import { RGLineVertexBeDroppedEventHandler } from '../../../types/types/relation-graph-models/types';
+export declare class RelationGraphWith4Line extends RelationGraphWith3Image {
+    constructor(options: RGOptions, listeners: RGListeners);
+    private _getJunctionPoint;
+    createLinePath(link: RGLink | RGElementLine, line: RGLine, ri: number): void;
+    createLineDrawInfo(link: RGLink | RGElementLine, line: RGLine): RGLinePathInfo | undefined;
+    generateLinePath(generateConfig: RGGenerateLineConfig): RGLinePathInfo;
+    throwLineError(errorCode: string, x: number, y: number): {
+        rgError: boolean;
+        errorCode: string;
+        x: number;
+        y: number;
+    };
+    createErrorLineValue(errorCode: string, x: number, y: number): RGLinePathInfo;
+    /**
+    this.options.layout.layoutDirection || 'h';
+    this.options.multiLineDistance
+    this.options.defaultJunctionPoint
+    lineRadius: this.options.defaultPolyLineRadius
+    **/
+    withLineJunctionPoints({ line, from, to, totalLinesBetweenNodes, currentLineIndex, defaultOptions }: RGGenerateLineConfig): RGGenerateLinePrams;
+    createLinePathData(linePathGenerateParmas: RGGenerateLinePrams): RGLinePathInfo;
+    getArrowMarkerId(line: RGLine, isStartArrow?: boolean): string | undefined;
+    getTextTransform(line: RGLine, textPosition: RGLineTextPosition): string;
+    generateLineTextStyle(lineConfig: RGGenerateLineConfig, linePathInfo: RGLinePathInfo): {
+        cssStyles: {
+            transform: string;
+            transformOrigin: string;
+        };
+        text?: undefined;
+    } | {
+        text: string;
+        cssStyles: {
+            transform: string;
+            transformOrigin: string;
+        };
+    };
+    generateLineTextStyle4TextPath(lineConfig: RGGenerateLineConfig): {
+        text: string;
+        textOffset: string;
+        textAnchor: string;
+        onPathStartOffset: string;
+        textRotate: number;
+    } | null;
+    onLineVertexBeDroppedOnConnectController(junctionPoint: RGJunctionPoint, $event: RGUserEvent, connectBoxDom?: HTMLElement, lineVertexBeDroppedEventHandler?: RGLineVertexBeDroppedEventHandler): void;
+}

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

@@ -0,0 +1,31 @@
+import { RGListeners, RGOptions } from '../types';
+import { RelationGraphWith4Line } from './RelationGraphWith4Line';
+export type RGCoordinate = {
+    x: number;
+    y: number;
+};
+export type RGClientXy = RGCoordinate;
+export type RGCViewXy = RGCoordinate;
+export type RGCanvasXy = RGCoordinate;
+export declare class RelationGraphWith5Zoom extends RelationGraphWith4Line {
+    constructor(options: RGOptions, listeners: RGListeners);
+    private _zooming;
+    zoom(buff: number, userZoomCenter?: RGClientXy, e?: WheelEvent): Promise<void>;
+    protected _zoomEnd(oldZoomValue: number, newZoomValue: number): boolean;
+    setZoom(finalZoom: number, userZoomCenter?: RGClientXy): void;
+    /**
+     * Get the coordinates mapped on the "relation-graph Component viewport" from the canvas coordinates
+     * @param clientXY = {x: e.clientX, y: e.clientY}
+     */
+    getCanvasXyByClientXy(clientXY: RGCoordinate): RGCoordinate;
+    /**
+     * Get the coordinates mapped on the "relation-graph Component viewport" from the canvas coordinates
+     * @param viewXy = {x: e.clientX - relationGraphViewBox.left, y: e.clientY - relationGraphViewBox.top}
+     */
+    getCanvasXyByViewXy(viewXy: RGCoordinate): RGCoordinate;
+    /**
+     * Get the coordinates mapped on the canvas from the "relation-graph Component viewport" coordinates
+     * @param canvasCoordinate = {x: node.x, y: node.y}
+     */
+    getViewXyByCanvasXy(canvasCoordinate: RGCoordinate): RGCoordinate;
+}

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

@@ -0,0 +1,18 @@
+import { RGListeners, RGNode, RGRectTarget, RGOptions } from '../types';
+import { RelationGraphWith5Zoom } from './RelationGraphWith5Zoom';
+export declare class RelationGraphWith6Effect extends RelationGraphWith5Zoom {
+    constructor(options: RGOptions, listeners: RGListeners);
+    /**
+     * Move the center of the canvas to the center of the viewport. Note: The center of the canvas refers to the center calculated based on the distribution of nodes, not the center point of the canvas.
+     */
+    moveToCenter(nodes?: (RGNode | RGRectTarget)[]): void;
+    /**
+     * Zoom to fit the appropriate size, which means making the specified nodes visible in the view and occupying the view as much as possible.
+     * @param nodes Optional, defaults to all nodes in the graph
+     */
+    zoomToFit(nodes?: (RGNode | RGRectTarget)[]): void;
+    enableNodeXYAnimation(): void;
+    disableNodeXYAnimation(): void;
+    enableCanvasAnimation(): void;
+    disableCanvasAnimation(): void;
+}

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

@@ -0,0 +1,33 @@
+import { RGLayouter, RGLayoutOptions, RGListeners, RGNode, RGOptions } from '../types';
+import { RelationGraphWith6Effect } from './RelationGraphWith6Effect';
+export declare class RelationGraphWith6Layout extends RelationGraphWith6Effect {
+    constructor(options: RGOptions, listeners: RGListeners);
+    /**
+     * Assign positions to the nodes in the current graph based on the layout configuration set in the options
+     */
+    doLayout(customRootNode?: RGNode | string): Promise<void>;
+    private _doLayout;
+    refresh(doLayout?: boolean): void;
+    private _mainGroupNodes;
+    placeOtherNodes(): void;
+    placeSingleNodes(singleNodes: RGNode[]): void;
+    placeOtherGroup(notPlacedNodes: RGNode[], placedNodes: RGNode[]): void;
+    /**
+     * If the current layout is force, you can call this method to start or stop the real-time force-directed calculation
+     */
+    toggleAutoLayout(): void;
+    private layouter;
+    /**
+     * If the current layout is force, you can call this method to start the force-directed calculation
+     */
+    startAutoLayout(): void;
+    /**
+     * If the current layout is force, you can call this method to stop the force-directed calculation
+     */
+    stopAutoLayout(): void;
+    /**
+     * Create a layouter
+     * @param layoutOptions
+     */
+    createLayout(layoutOptions: RGLayoutOptions, isMainLayout?: boolean): RGLayouter;
+}

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

@@ -0,0 +1,74 @@
+import { CreatingLinePlotOptions, CreatingNodePlotOptions, RGLine, RGLineConnectEventHandler, RGLineTarget, RGLink, RGListeners, RGNode, RGOptions, RGPosition, RGSelectionView, RGUserEvent } from '../types';
+import { RelationGraphWith6Layout } from './RelationGraphWith6Layout';
+export declare class RelationGraphWith7Event extends RelationGraphWith6Layout {
+    constructor(options: RGOptions, listeners: RGListeners);
+    setCheckedNode(nodeId: string): void;
+    setCheckedLinkAndLine(link: RGLink, line: RGLine): void;
+    setCheckedLine(line: RGLine): void;
+    clearChecked(): void;
+    clearSelected(): void;
+    updateNodeOffsetSize(nodeId: string, width: number, height: number): void;
+    prevClickTime: number;
+    onNodeClick(node: RGNode, e: RGUserEvent): void;
+    protected nodeXYBeforeDrag: {
+        [nodeId: string]: {
+            x: number;
+            y: number;
+        };
+    };
+    onNodeDragStart(willMoveNode: RGNode, e: RGUserEvent): void;
+    onNodeDraged(node: RGNode, x_buff: number, y_buff: number, e: RGUserEvent): void;
+    onNodeDragEnd(node: RGNode, e: RGUserEvent, x_buff: number, y_buff: number): void;
+    onLineClick(line: RGLine, link: RGLink, e: RGUserEvent): void;
+    expandOrCollapseNode(node: RGNode, e: RGUserEvent): void;
+    expandNode(node: RGNode, e?: RGUserEvent): void;
+    collapseNode(node: RGNode, e?: RGUserEvent): void;
+    private doLayoutWhenExpandedOrCollapsed;
+    onCanvasDragEnd(e: RGUserEvent): void;
+    onCanvasClick(e: RGUserEvent): void;
+    onCanvasSelectionEnd(selectionView: RGSelectionView, e: RGUserEvent): void;
+    startCreatingNodePlot(e: RGUserEvent, setting: CreatingNodePlotOptions): void;
+    startCreatingLinePlot(e: RGUserEvent, setting: CreatingLinePlotOptions): void;
+    movingListener: any;
+    stopCreatingLinePlot(): void;
+    _currentMovingLineTarget: RGLineTarget | null;
+    onMovingWhenCreatingLinePlot($event: MouseEvent): void;
+    onCanvasClickWhenCreatingLinePlot($event: RGUserEvent): void;
+    step1EventTime: number;
+    onNodeClickWhenCreatingLinePlot(node: RGNode): void;
+    onCreateLineCallback: RGLineConnectEventHandler | undefined;
+    onCreateLine(from: RGNode, to: RGNode | RGPosition): boolean | import('../types').RGCoordinate | undefined;
+    isNode(el: HTMLElement): RGNode | undefined;
+    isLine(el: HTMLElement): RGLink | undefined;
+    isLink(el: HTMLElement): RGLink | undefined;
+    onContextmenu(e: RGUserEvent): void;
+    fullscreen(newValue?: boolean): Promise<void>;
+    focusNodeById(nodeId: string): void;
+    focusRootNode(): void;
+    handleSelect(thisNode: RGNode): void;
+    private _wheelAction;
+    private _wheelBuff;
+    onMouseWheel(e: WheelEvent): true | undefined;
+    private _onMouseWheel;
+    /**
+     * Scroll the canvas
+     * @param buffX - The amount to scroll
+     * @param buffY - The amount to scroll
+     */
+    scrollView(buffX: number, buffY: number): void;
+    onLineDragStart(line: RGLine, e: RGUserEvent): void;
+    onLineDragEnd(x_buff: number, y_buff: number, e: RGUserEvent): void;
+    onCanvasDragStart(e: RGUserEvent): void;
+    startMoveCanvas(e: RGUserEvent, forceStartMove?: boolean): void;
+    protected onCanvasDragging(newX: number, newY: number, buffX: number, buffY: number): void;
+    onCanvasDragStop(x_buff: number, y_buff: number, e: RGUserEvent): void;
+    startCreateSelection(e: RGUserEvent): void;
+    private _fullscreenchangeHandler;
+    addFullscreenListener(): void;
+    removeFullscreenListener(): void;
+    /**
+     * Sleep for a specified amount of time
+     * @param time - The time to sleep in milliseconds
+     */
+    sleep(time: number): Promise<void>;
+}

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

@@ -0,0 +1,23 @@
+import { RGJsonData, RGListeners, RGOptions } from '../types';
+import { RelationGraphWith7Event } from './RelationGraphWith7Event';
+export declare class RelationGraphWith8Update extends RelationGraphWith7Event {
+    constructor(options: RGOptions, listeners: RGListeners);
+    dataUpdated(): void;
+    setOptions(options: RGOptions): void;
+    setRootNodeId(rootNodeId: string): void;
+    getRootNode(): import('../types').RGNode | undefined;
+    setCheckedNode(nodeId: string): void;
+    getCheckedNode(): import('../types').RGNode | undefined;
+    getCheckedLine(): import('../types').RGFakeLine | undefined;
+    getSelectedNodes(): import('../types').RGNode[];
+    getEditingNodes(): import('../types').RGNode[];
+    setJsonData(jsonData: RGJsonData): Promise<void>;
+    /**
+    * Append data to the graph
+    * @param jsonData
+    * @param isRelayout Whether to re-layout after appending data
+    */
+    appendJsonData(jsonData: RGJsonData, isRelayout?: boolean): Promise<void>;
+    applyInitialData(initialData: RGJsonData): Promise<void>;
+    fitContentHeight(padding?: number): void;
+}