ts-graphviz
    Preparing search index...

    Class Graph

    DOT object class representing a graph.

    Hierarchy (View Summary)

    Index

    Constructors

    constructor

    Properties

    attributes comment? id? strict

    Accessors

    $$type directed edges nodes size subgraphs values

    Methods

    addEdge addNode addSubgraph apply clear createEdge createNode createSubgraph delete edge existEdge existNode existSubgraph get getNode getSubgraph graph node removeEdge removeNode removeSubgraph set subgraph with

    Constructors

    Properties

    attributes: Readonly<GraphCommonAttributes> = ...
    comment?: string

    Comments to include when outputting with toDot.

    id?: string
    strict: boolean

    Strict 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.

    Accessors

    • get $$type(): "Graph"

      The type of the DotObjectType.

      Returns "Graph"

    • get directed(): boolean

      Returns boolean

    • get size(): number

      Size of the set of keys and values held by the DOT object.

      Returns number

    Methods

    • Delete the value of an attribute from a DOT object by specifying a key.

      Parameters

      • key: values

      Returns void

    • Create 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";
      // }

      Parameters

      Returns EdgeModel

    • 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",
      //   ];
      // }

      Parameters

      Returns EdgeModel

    • 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",
      //   ];
      // }

      Parameters

      Returns void

    • Check if the Node exists in the graph.

      Parameters

      • nodeId: string

      Returns boolean

    • Get the value of an attribute by a DOT object by specifying its key.

      If the value corresponding to the key does not exist, undefined is returned.

      Type Parameters

      • K extends values

      Parameters

      • key: K

      Returns undefined | Attribute<K>

    • Get Node in cluster by specifying id.

      If there is no Node with the specified id in the graph, return undefined.

      Parameters

      • id: string

      Returns undefined | NodeModel

    • 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",
      //   ];
      // }

      Parameters

      Returns void

    • 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";
      // }

      Parameters

      • id: string

        Node ID.

      • Optionalcallback: (node: NodeModel) => void

        Callbacks for manipulating created or retrieved node.

      Returns NodeModel

    • 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",
      //   ];
      // }

      Parameters

      • id: string

        Node ID.

      • attributes: NodeAttributesObject

        Object of attributes to be adapted to the node.

      • Optionalcallback: (node: NodeModel) => void

        Callbacks for manipulating created or retrieved node.

      Returns NodeModel

    • 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",
      //   ];
      // }

      Parameters

      Returns void

    • 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";
      //   }
      // }

      Parameters

      • id: string

        Subgraph ID.

      • Optionalcallback: (subgraph: SubgraphModel) => void

        Callbacks for manipulating created or retrieved subgraph.

      Returns SubgraphModel

    • 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";
      //   }
      // }

      Parameters

      • id: string

        Subgraph ID.

      • attributes: SubgraphAttributesObject

        Object of attributes to be adapted to the subgraph.

      • Optionalcallback: (subgraph: SubgraphModel) => void

        Callbacks for manipulating created or retrieved subgraph.

      Returns SubgraphModel

    • 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";
      //   }
      // }

      Parameters

      • attributes: SubgraphAttributesObject

        Object of attributes to be adapted to the subgraph.

      • Optionalcallback: (subgraph: SubgraphModel) => void

        Callbacks for manipulating created or retrieved subgraph.

      Returns SubgraphModel

    • 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.

      Parameters

      • Optionalcallback: (subgraph: SubgraphModel) => void

        Callbacks for manipulating created or retrieved subgraph.

      Returns SubgraphModel

    Settings

    Member Visibility

    On This Page

    Constructors
    Properties
    Accessors
    Methods