Skip to main content Inicio Creadores syncfusion react-ui-components-skills syncfusion-react-diagram
syncfusion-react-diagram Create and customize visual diagrams in React using Syncfusion Diagrams. Trigger for requests involving React component setup, nodes and connectors, flowcharts, org charts, process diagrams, BPMN or UML models, ER diagrams, layout algorithms, swimlanes, symbol palettes, and interactive diagram visualization features.
Ir a la instalación Skills Marketplace Descubre y explora habilidades de IA creadas por la comunidad.
Instalar con Codex o Claude Copia este prompt, pégalo en Codex, Claude u otro asistente, y deja que revise la página de la skill y la instale por ti.
Copiar promptMostrar detalles del prompt Un comando directo omite el prompt de revisión. Revisa el origen antes de ejecutarlo.
npx skills add https://github.com/syncfusion/react-ui-components-skills --skill syncfusion-react-diagramEl comando permanece en una sola línea. Desplázate horizontalmente para revisarlo antes de copiarlo.
¿Prefieres una copia local? Descarga los archivos que SkillsMP tiene disponibles ahora.
Descargar Zip Descargando... syncfusion-react-accordion Guide users to implement Syncfusion React Accordion component for collapsible content panels. Use this skill whenever the user needs to create expandable/collapsible sections, accordion layouts, tabbed content panels, multi-step forms, FAQs, or navigation with expandable items. Covers component setup, expand modes, animations, dynamic content loading, styling, events, lifecycle, React hooks integration, and complete API reference.
Create responsive navigation headers with AppBar component. Build top, bottom, or sticky app bars with buttons, menus, icons, and sidebars. Use when building navigation elements, toolbars, action bars, or responsive headers with dynamic content layout. Includes color modes (Light, Dark, Primary, Inherit), size modes (Regular, Prominent, Dense), spacing, separators, and full accessibility support.
Ocupaciones relacionadas SOC
Basado en la clasificación ocupacional SOC
Explorador de archivos
18 archivos name syncfusion-react-diagram description Create and customize visual diagrams in React using Syncfusion Diagrams. Trigger for requests involving React component setup, nodes and connectors, flowcharts, org charts, process diagrams, BPMN or UML models, ER diagrams, layout algorithms, swimlanes, symbol palettes, and interactive diagram visualization features. metadata {"author":"Syncfusion Inc","version":"34.1.29","category":"Data Visualization"}
Syncfusion React Diagram
The Syncfusion React Diagram component enables building rich, interactive diagrams including flowcharts, organizational charts, BPMN process flows, UML diagrams, mind maps, and network diagrams. It renders using SVG and supports extensive customization through nodes, connectors, ports, annotations, layouts, and data binding.
Table of Contents
When to Use This Skill Use this skill when users need to:
Build flowcharts representing processes, decision trees, or workflows
Create org charts from hierarchical or flat data sources
Model BPMN diagrams with activities, events, gateways, and flows
Draw UML diagrams including class diagrams and sequence diagrams
Visualize mind maps or radial layouts from data
Design network/entity diagrams with nodes and relationship connectors
Implement swimlane diagrams with lanes and phases
Drag and drop shapes from a symbol palette onto a canvas
Bind data to automatically generate diagram structure
Serialize and restore diagram state as JSON
Export or print diagram content as image/SVG
Important: API Verification Required API Verification Required : Always verify API class names, properties, and signatures by reading reference files (references/*.md) BEFORE generating code examples. Do not assume or infer class names.
Component Overview The Diagram component is built around:
Nodes — Graphical shapes (rectangles, circles, flow shapes, custom) placed on the canvas
Connectors — Lines/arrows linking nodes or freestanding points
Annotations — Text labels attached to nodes or connectors
Ports — Named connection points on nodes for precise connector anchoring
Layouts — Automatic arrangement algorithms (hierarchical, org-chart, mindmap, radial, flowchart)
Symbol Palette — Sidebar of draggable shape symbols
Module System — Opt-in feature modules (Inject directive) to keep bundle size lean
All diagram elements are rendered using SVG for crisp, resolution-independent graphics.
Documentation and Navigation Guide
Getting Started
First-time setup of the Diagram component
Installing packages, CSS imports, and theme configuration
Creating a minimal DiagramComponent
Understanding the Inject module system
Next.js or Preact integration
npm install and dependencies
Vite/CRA project setup
CSS theme import paths
Basic DiagramComponent with nodes and connectors
Module injection with <Inject services={[...]} />
Next.js and Preact usage notes
Nodes
Adding, positioning, and sizing nodes
Customizing node appearance (fill, stroke, shadow)
Working with node shapes (Flow, Basic, Path, Image, HTML)
Handling node events (click, drag, resize)
Expanding/collapsing nodes at runtime
Setting default node properties via getNodeDefaults
Creating nodes via nodes collection
offsetX/offsetY, width/height positioning
Adding/removing nodes at runtime (diagram.add, diagram.remove)
Style properties (fill, strokeColor, opacity, gradient)
getNodeDefaults pattern for consistent styling
Node expand/collapse with expandIcon/collapseIcon
Node interaction events
Connectors
Drawing lines/arrows between nodes or freestanding points
Choosing connector type (Straight, Orthogonal, Bezier)
Configuring connector segments and routing
Customizing decorator (arrow) shapes
Setting sourceID/targetID to link nodes
Setting getConnectorDefaults for consistent styling
Connector types: Straight, Orthogonal, Bezier
sourcePoint/targetPoint for freestanding connectors
sourceID/targetID for node-to-node connections
Multiple segment configuration
Bezier control points and segment edit orientation
Arrow/decorator customization
Connector events and interaction
getConnectorDefaults pattern
Labels and Annotations
Adding text labels to nodes or connectors
Styling annotation text (font, color, bold, alignment)
Making labels draggable or editable
Positioning labels relative to nodes/connectors
Handling label-specific events
annotations array on nodes and connectors
Label content, style, offset, alignment
Node labels vs. connector labels
Label interaction (edit on double-click, drag)
Label appearance (background, border, padding)
Label events
Ports
Creating named connection points on nodes
Controlling where connectors attach to a node
Styling and positioning ports
Restricting connector connections to specific ports
Handling port interaction events
Port types and ports array on nodes
Port positioning (offset, alignment)
Port appearance (shape, fill, stroke)
Connecting connectors to specific ports via sourcePortID/targetPortID
Port interaction and visibility options
Port events
Shapes and Styles
Choosing the right shape type (Flow, Basic, Path, Image, HTML, Native SVG)
Applying fill colors, gradients, and stroke styles
Customizing node appearance with CSS or themes
Understanding shape property structure
shape.type options: Flow, Basic, Path, Image, HTML, Native
Flowchart shape values (Terminator, Process, Decision, etc.)
Basic shape values (Rectangle, Ellipse, Diamond, etc.)
Style properties: fill, strokeColor, strokeWidth, strokeDashArray, opacity
Linear and radial gradients
Shadow effect
CSS class-based styling
BPMN Diagrams
Modeling business process flows using BPMN notation
Using BPMN-specific shapes (activities, events, gateways)
Drawing sequence flows, message flows, associations
Adding data objects, data sources, text annotations, and groups
BpmnDiagrams module injection
BPMN shape type: shape.type = 'Bpmn'
Activities: Task types, Subprocess, Expanded Subprocess
Events: Start, End, Intermediate events and their triggers
Gateways: Exclusive, Parallel, Inclusive, Complex
Flows: Sequence, Message, Association
Data objects and data sources
BPMN groups and text annotations
UML Diagrams
Building UML class diagrams with attributes and methods
Modeling relationships (association, generalization, dependency)
Creating UML sequence diagrams with lifelines and messages
Working with classifiers (class, interface, enumeration, collaboration)
UML class diagram shapes (shape.type = 'UmlClassifier')
Classifier types: Class, Interface, Enumeration, Collaboration
Attributes, operations, and members syntax
UML relationship connector types
UML sequence diagram (shape.type = 'UmlActivity')
Lifelines, messages, and fragments
ER Diagrams
Building Entity Relationship diagrams to visualize database structure
Creating ER entity nodes representing database tables with fields
Defining field properties (primary key, foreign key, data type, constraints)
Adding or removing entity fields at runtime
Connecting entities with ER relationship connectors and multiplicity
Styling ER entity headers, field rows, and alternating row colors
Tracking entity field changes via events
ErDiagrams module injection (Diagram.Inject(ErDiagrams))
ER entity node: shape.type = 'Er' with ErShapeModel
Header configuration: annotation, height, style
Field configuration: id, name, dataType, isPrimaryKey, isForeignKey, constraints
addErField / removeErField runtime methods
fieldDefaults: alternateRowColors, height
Field-level and node-level style overrides
erEntityChanged event for tracking field modifications
ER relationship connectors with ErConnectorShapeModel
Crow's Foot multiplicity: One, Many, ZeroOrOne, OneOrMany, ZeroOrMany, OneAndOnlyOne
Layouts
Automatically arranging nodes in a tree, hierarchy, or radial pattern
Creating org charts driven by parent-child data
Building mind maps from data sources
Configuring flowchart layouts with decision/process shapes
Customizing layout spacing, orientation, and alignment
HierarchicalTree — top-down/left-right tree layouts
OrganizationalChart — classic org chart with getNodeDefaults/getConnectorDefaults
MindMap — branching mind map layout
RadialTree — circular radial layout
Flowchart layout (automatic flow arrangement)
ComplexHierarchicalTree for multi-parent hierarchies
layout property: type, orientation, margin, horizontalSpacing, verticalSpacing
LayoutAnimation module
Layout events
Swimlanes
Creating multi-lane process diagrams
Adding phases to represent timeline or stages
Configuring swimlane headers and orientation
Placing child nodes inside lanes
Using swimlane shapes from the symbol palette
Swimlane shape.type = 'SwimLane'
Lanes and phases configuration
Header text, size, and orientation
Child nodes inside lanes
Swimlane palette integration
Swimlane interaction (add/remove lanes)
Groups and Containers
Grouping multiple nodes for collective movement/selection
Adding/removing children from groups at runtime
Using container nodes to visually bound child nodes
Configuring padding, fit-to-children behavior
Group node shape.type = 'Group' and children array
Grouping/ungrouping nodes via diagram methods
Adding children at runtime
Container node configuration
Padding and auto-fit behavior for containers
Symbol Palette
Adding a drag-and-drop shape sidebar to your diagram app
Defining custom symbol sets (palettes)
Customizing palette icon size, search behavior, and accordion
Handling symbolDragEnter/symbolDrop events
SymbolPaletteComponent setup alongside DiagramComponent
Defining palettes with symbol arrays
getSymbolInfo for display customization
Palette accordion: expanding/collapsing groups
Search functionality
Symbol preview size configuration
Palette events
Data Binding
Generating diagrams automatically from JSON or remote data
Mapping id and parentId fields for hierarchy
Using DataManager for remote or filtered data
Customizing node appearance based on data properties (setNodeTemplate)
Connecting to a PostgreSQL or external data source
dataSourceSettings property
id, parentId field mapping
DataManager with local arrays or remote URLs
getNodeDefaults and setNodeTemplate for data-driven styling
PostgreSQL data source integration
Rendering org charts from flat JSON data
Interaction and Tools
Enabling/disabling node and connector interactions (drag, resize, select)
Switching diagram tool modes (pointer, draw, pan)
Configuring diagram constraints
Adding custom keyboard commands or toolbar actions
Implementing undo/redo
Setting up context menus or user handles
DiagramConstraints, NodeConstraints, ConnectorConstraints
tool property: DiagramTools.Default, ZoomPan, DrawOnce
Selection, drag, resize, rotate interactions
commands for keyboard shortcuts
Undo/Redo (UndoRedo module)
Context menu (DiagramContextMenu module)
User handles for custom action buttons on nodes
Snapping module and snap settings
Serialization and Export
Saving and restoring diagram state as JSON
Exporting the diagram as PNG, JPEG, or SVG
Printing diagram content
Importing Visio (.vsdx) files
Migrating from EJ1 diagram format
diagram.saveDiagram() and diagram.loadDiagram(json)
PrintAndExport module injection
Export settings: format, region, margin, background
Print dialog and options
Visio file import (visio.md)
EJ1 serialization compatibility (Ej1Serialization module)
Diagram Settings
Managing diagram layers (visibility, locking, ordering)
Enabling virtualization for performance with large diagrams
Configuring grid lines, snapping, and rulers
Setting page size, orientation, and margins
Configuring scroll behavior and limits
Adding tooltips to diagram elements
Using the Overview component for minimap navigation
Enabling localization or RTL support
Understanding accessibility features
Layers: add, lock, set visibility, active layer
Virtualization module for large diagrams
Grid lines: dots, lines, snap settings
Ruler configuration
scrollSettings: scrollLimit, minZoom, maxZoom
pageSettings: size, orientation, background, multiplePage
Tooltip on nodes and connectors
OverviewComponent minimap setup
Localization and RTL
ARIA and keyboard accessibility
Quick Start Example
Minimal Flowchart import { DiagramComponent , NodeModel , ConnectorModel , Inject , UndoRedo } from '@syncfusion/ej2-react-diagrams' ;
const nodes : NodeModel [] = [
{ id : 'start' , offsetX : 300 , offsetY : 80 , width : 140 , height : 50 ,
shape : { type : 'Flow' , shape : 'Terminator' }, annotations : [{ content : 'Start' }] },
{ id : 'process' , offsetX : 300 , offsetY : 180 , width : 140 , height : 50 ,
shape : { type : 'Flow' , shape : 'Process' }, annotations : [{ content : 'Process' }] },
{ id : 'end' , offsetX : 300 , offsetY : 290 , width : 140 , height : 50 ,
shape : { type : 'Flow' , shape : 'Terminator' }, annotations : [{ content : 'End' }] },
];
const connectors : ConnectorModel [] = [
{ id : 'c1' , sourceID : 'start' , targetID : 'process' },
{ id : 'c2' , sourceID : 'process' , targetID : 'end' },
];
export default function App ( ) {
return (
<DiagramComponent id ="diagram" width ={ '100 %'} height ={ '500px '}
nodes ={nodes} connectors ={connectors}
getConnectorDefaults ={(obj) => { obj.type = 'Orthogonal'; return obj; }}>
<Inject services ={[UndoRedo]} />
</DiagramComponent >
);
}
CSS import: @import '@syncfusion/ej2-react-diagrams/styles/material.css'; and peer CSS for ej2-base, ej2-popups, ej2-splitbuttons, ej2-navigations.
Common Patterns
Pattern 1: Org Chart from Data Source import { DiagramComponent , HierarchicalTree , DataBinding , Inject } from '@syncfusion/ej2-react-diagrams' ;
import { DataManager } from '@syncfusion/ej2-data' ;
const data = [
{ Name : 'CEO' },
{ Name : 'CTO' , ReportingPerson : 'CEO' },
{ Name : 'Dev Lead' , ReportingPerson : 'CTO' },
];
export default function App ( ) {
return (
<DiagramComponent id ="diagram" width ={ '100 %'} height ={ '500px '}
dataSourceSettings ={{ id: 'Name ', parentId: 'ReportingPerson ', dataManager: new DataManager (data ) }}
layout ={{ type: 'OrganizationalChart ' }}
getNodeDefaults ={(node) => { node.width = 120; node.height = 40; return node; }}
getConnectorDefaults={(obj) => { obj.type = 'Orthogonal'; return obj; }}>
<Inject services ={[DataBinding, HierarchicalTree ]} />
</DiagramComponent >
);
}
Pattern 2: Save and Load Diagram State Use diagramInstance.saveDiagram() to serialize to JSON string; diagramInstance.loadDiagram(json) to restore. Inject UndoRedo for history support. For full examples see references/serialization-and-export.md .
Pattern 3: Diagram with Symbol Palette Render SymbolPaletteComponent alongside DiagramComponent. Define palettes with shape arrays, set symbolHeight/symbolWidth, and users can drag shapes onto the canvas. For full examples see references/symbol-palette.md .
Module Injection Reference Inject only the modules your diagram uses: <Inject services={[HierarchicalTree, DataBinding, UndoRedo]} />
Module Purpose HierarchicalTreeTree and org chart layouts MindMapMind map layout RadialTreeRadial/circular layout ComplexHierarchicalTreeMulti-parent hierarchies DataBindingData source integration UndoRedoUndo/redo history SnappingGrid snapping PrintAndExportExport & print BpmnDiagramsBPMN shapes ErDiagramsER diagram shapes and relationships LayoutAnimationAnimated layouts DiagramContextMenuRight-click context menu ConnectorBridgingBridge overlapping connectors ConnectorEditingEdit connector segments Ej1SerializationLoad EJ1 diagram JSON
Key Props Prop Type Description nodesNodeModel[]Array of node definitions connectorsConnectorModel[]Array of connector definitions layoutLayoutModelAutomatic layout configuration dataSourceSettingsDataSourceModelData source for auto-generated diagrams getNodeDefaults(node) => NodeModelDefault properties for all nodes getConnectorDefaults(obj) => ConnectorModelDefault properties for all connectors setNodeTemplate(node) => DiagramElementCustom template rendering for nodes toolDiagramToolsActive interaction tool mode snapSettingsSnapSettingsModelGrid and snap configuration scrollSettingsScrollSettingsModelScroll limits and zoom bounds pageSettingsPageSettingsModelPage size, orientation, background constraintsDiagramConstraintsEnable/disable diagram-level interactions widthstringDiagram canvas width (e.g., '100%') heightstringDiagram canvas height (e.g., '600px')
Related Components
Chart - Data-driven charts and graphs
Kanban - Kanban board visualization
Data Grid - Tabular data display