Abstract Optional id: stringOptional attributes: GraphAttributesObjectOptional id: stringOptional strict: booleanOptional attributes: GraphAttributesObjectOptional strict: booleanOptional attributes: GraphAttributesObjectOptional attributes: GraphAttributesObjectPrivate #privatePrivate #privateReadonly attributesOptional commentComments to include when outputting with toDot.
Abstract Readonly directedOptional Readonly idStrict mode.
A graph may also be described as strict. This forbids the creation of multi-edges, i.e., there can be at most one edge with a given tail node and head node in the directed case. For undirected graphs, there can be at most one edge connected to the same two nodes. Subsequent edge statements using the same two nodes will identify the edge with the previously defined one and apply any attributes given in the edge statement.
The type of the DotObjectType.
Size of the set of keys and values held by the DOT object.
Subgraph objects in the graph.
Add Edge to the graph.
Add a Node to the graph.
Add a Subgraph to the graph.
Apply keys and values that can be specified for DOT objects collectively.
An array of objects or tuples of attribute key/value pairs.
Create Edge and add it to the graph.
Optional attributes: EdgeAttributesObjectCreate a Node in the graph.
Optional attributes: NodeAttributesObjectCreate a Subgraph and add it to the graph.
Optional id: stringSubgraph ID
Optional attributes: SubgraphAttributesObjectSubgraph attribute object
Optional attributes: SubgraphAttributesObjectCreate a edge.
By specifying a callback function, the target edge can be received and manipulated as an argument.
const G = digraph('G', (g) => {
// Create a edge.
g.edge(['a', 'b']);
});
console.log(toDot(G));
// digraph "G" {
// "a" -> "b";
// }
Nodes.
Optional callback: ((edge) => void)Callbacks for manipulating created or retrieved edge.
Create a edge and adapt the attributes.
By specifying a callback function, the target edge can be received and manipulated as an argument.
const G = digraph('G', (g) => {
// Create a edge and specifying its attributes.
g.edge(['a', 'b'], {
[attribute.color]: 'red',
[attribute.label]: 'my label',
});
});
console.log(toDot(G));
// digraph "G" {
// "a" -> "b" [
// color = "red",
// label = "my label",
// ];
// }
Object of attributes to be adapted to the edge.
Optional callback: ((edge) => void)Callbacks for manipulating created or retrieved edge.
Set a common attribute for the edges in the graph.
const G = digraph('G', (g) => {
// Set a common attribute for the edges in the graph.
g.edge({
[attribute.color]: 'red',
[attribute.label]: 'my label',
});
});
console.log(toDot(G));
// digraph "G" {
// edge [
// color = "red",
// label = "my label",
// ];
// }
Object of attributes to be adapted to the edges.
Check if the Edge exists in the graph.
Check if the Subgraph exists in the graph.
Get Subgraph in cluster by specifying id.
If there is no Subgraph with the specified id in the graph, return undefined.
Set a common attribute for the graph in the graph.
const G = digraph('G', (g) => {
g.graph({
[attribute.color]: 'red',
[attribute.label]: 'my label',
});
});
console.log(toDot(G));
// digraph "G" {
// graph [
// color = "red",
// label = "my label",
// ];
// }
Object of attributes to be adapted to the graph.
Create a node by specifying its id (or get it if it already exists).
By specifying a callback function, the target node can be received and manipulated as an argument.
const G = digraph('G', (g) => {
// Create a node with id as A.
g.node('A');
});
console.log(toDot(G));
// digraph "G" {
// "A";
// }
Node ID.
Optional callback: ((node) => void)Callbacks for manipulating created or retrieved node.
Create a node (or get one if it already exists) and adapt the attributes.
By specifying a callback function, the target node can be received and manipulated as an argument.
const G = digraph('G', (g) => {
// Create a node by specifying its id and specifying its attributes.
g.node('A', {
[attribute.color]: 'red',
[attribute.label]: 'my label',
});
});
console.log(toDot(G));
// digraph "G" {
// "A" [
// color = "red",
// label = "my label",
// ];
// }
Node ID.
Object of attributes to be adapted to the node.
Optional callback: ((node) => void)Callbacks for manipulating created or retrieved node.
Set a common attribute for the nodes in the graph.
const G = digraph('G', (g) => {
// Set a common attribute for the nodes in the graph.
g.node({
[attribute.color]: 'red',
[attribute.label]: 'my label',
});
});
console.log(toDot(G));
// digraph "G" {
// node [
// color = "red",
// label = "my label",
// ];
// }
Object of attributes to be adapted to the nodes.
Remove Edge from the graph.
Remove Node from the graph.
Remove Subgraph from the graph.
Set a value, by specifying the key of the attributes in the DOT object.
Create a subgraph by specifying its id (or get it if it already exists).
By specifying a callback function, the target subgraph can be received and manipulated as an argument.
const G = digraph('G', (g) => {
// Create a cluster with id as A.
g.subgraph('A', (A) => {
// Create a node with id as A1 in cluster A.
A.node('A1');
});
});
console.log(toDot(G));
// digraph "G" {
// subgraph "A" {
// "A1";
// }
// }
Subgraph ID.
Optional callback: ((subgraph) => void)Callbacks for manipulating created or retrieved subgraph.
Create a subgraph (or get one if it already exists) and adapt the attributes.
By specifying a callback function, the target subgraph can be received and manipulated as an argument.
const G = digraph('G', (g) => {
// Create a cluster with id as A and specifying its attributes.
g.subgraph('A', { [attribute.color]: 'red', [attribute.label]: 'my label' }, (A) => {
// Create a node with id as A1 in cluster A.
A.node('A1');
});
});
console.log(toDot(G));
// digraph "G" {
// subgraph "A" {
// color = "red";
// label = "my label";
// "A1";
// }
// }
Subgraph ID.
Object of attributes to be adapted to the subgraph.
Optional callback: ((subgraph) => void)Callbacks for manipulating created or retrieved subgraph.
Create anonymous subgraphs and and adapt the attributes.
By specifying a callback function, the target subgraph can be received and manipulated as an argument.
const G = digraph('G', (g) => {
// Create a anonymous cluster and specifying its attributes.
g.subgraph({ [attribute.color]: 'red', [attribute.label]: 'my label' }, (A) => {
// Create a node with id as A1 in anonymous cluster.
A.node('A1');
});
});
console.log(toDot(G));
// digraph "G" {
// subgraph {
// color = "red";
// label = "my label";
// "A1";
// }
// }
Object of attributes to be adapted to the subgraph.
Optional callback: ((subgraph) => void)Callbacks for manipulating created or retrieved subgraph.
Create anonymous subgraphs and manipulate them with callback functions.
By specifying a callback function, the target subgraph can be received and manipulated as an argument.
Optional callback: ((subgraph) => void)Callbacks for manipulating created or retrieved subgraph.
Generated using TypeDoc
Base class representing a root graph(digraph, graph).