ts-graphviz 0.16.0 → 1.0.0-1

package/lib/core/index.js

@@ -0,0 +1,444 @@
+import { isNodeRefGroupLike, toNodeRefGroup, toNodeRef, isNodeRefLike } from '#/lib/common';
+import { fromModel, stringify } from '#/lib/ast';
+
+const attribute = new Proxy(Object.freeze({}), {
+  get: (_, key) => key,
+});
+
+/**
+ * Classes implemented in the 'ts-graphviz' library are designed to inherit from this class.
+ */
+class GraphvizObject {}
+/**
+ * Classes implemented in the 'ts-graphviz' library that implement the `toDot` method are designed to inherit from this class.
+ */
+class DotObject extends GraphvizObject {}
+/**
+ */
+class AttributesBase extends DotObject {
+  /** @hidden */
+  #attrs = new Map();
+  constructor(attributes) {
+    super();
+    if (attributes !== undefined) {
+      this.apply(attributes);
+    }
+  }
+  get values() {
+    return Array.from(this.#attrs.entries());
+  }
+  /** The size of the attribute. */
+  get size() {
+    return this.#attrs.size;
+  }
+  /** The size of the attribute. */
+  get(key) {
+    return this.#attrs.get(key);
+  }
+  /** Set a value to the attribute. */
+  set(key, value) {
+    if (value !== null && value !== undefined) {
+      this.#attrs.set(key, value);
+    }
+  }
+  delete(key) {
+    this.#attrs.delete(key);
+  }
+  apply(attributes) {
+    const entries = Array.isArray(attributes) ? attributes : Object.entries(attributes);
+    for (const [key, value] of entries) {
+      this.set(key, value);
+    }
+  }
+  clear() {
+    this.#attrs.clear();
+  }
+}
+/**
+ * A set of attribute values for any object.
+ */
+class AttributesGroupModel extends AttributesBase {
+  /** Comments to include when outputting with toDot. */
+  comment;
+}
+/**
+ * A set of attribute values for any object.
+ */
+class AttributeList extends AttributesBase {
+  $$kind;
+  get $$type() {
+    return 'AttributeList';
+  }
+  /** Comments to include when outputting with toDot. */
+  comment;
+  constructor($$kind, attributes) {
+    super(attributes);
+    this.$$kind = $$kind;
+  }
+}
+/**
+ * Base class for clusters.
+ * @hidden
+ */
+class GraphBase extends AttributesBase {
+  /** Cluster ID */
+  id;
+  /** Comments to include when outputting with toDot. */
+  comment;
+  /**
+   * Nodes in the cluster.
+   * @hidden
+   */
+  get nodes() {
+    return Array.from(this.#objects.nodes.values());
+  }
+  /**
+   * Edges in the cluster.
+   * @hidden
+   */
+  get edges() {
+    return Array.from(this.#objects.edges.values());
+  }
+  /**
+   * Subgraphs in the cluster.
+   * @hidden
+   */
+  get subgraphs() {
+    return Array.from(this.#objects.subgraphs.values());
+  }
+  #objects = {
+    nodes: new Map(),
+    edges: new Set(),
+    subgraphs: new Set(),
+  };
+  /**
+   * Add a Node to the cluster.
+   */
+  addNode(node) {
+    this.#objects.nodes.set(node.id, node);
+  }
+  /**
+   * Add Edge to the cluster.
+   */
+  addEdge(edge) {
+    this.#objects.edges.add(edge);
+  }
+  /**
+   * Add a Subgraph to the cluster.
+   */
+  addSubgraph(subgraph) {
+    this.#objects.subgraphs.add(subgraph);
+  }
+  /**
+   * Check if the Node exists in the cluster.
+   */
+  existNode(nodeId) {
+    return this.#objects.nodes.has(nodeId);
+  }
+  /**
+   * Check if the Edge exists in the cluster.
+   */
+  existEdge(edge) {
+    return this.#objects.edges.has(edge);
+  }
+  /**
+   * Check if the Subgraph exists in the cluster.
+   */
+  existSubgraph(subgraph) {
+    return this.#objects.subgraphs.has(subgraph);
+  }
+  createSubgraph(...args) {
+    const id = args.find((arg) => typeof arg === 'string');
+    const attributes = args.find((arg) => typeof arg === 'object');
+    const graph = new Subgraph(id, attributes);
+    this.#objects.subgraphs.add(graph);
+    return graph;
+  }
+  /**
+   * Remove Node from the cluster.
+   */
+  removeNode(node) {
+    this.#objects.nodes.delete(typeof node === 'string' ? node : node.id);
+  }
+  /**
+   * Remove Edge from the cluster.
+   */
+  removeEdge(edge) {
+    this.#objects.edges.delete(edge);
+  }
+  /**
+   * Remove Subgraph from the cluster.
+   */
+  removeSubgraph(subgraph) {
+    this.#objects.subgraphs.delete(subgraph);
+  }
+  /**
+   * Create a Node in the cluster.
+   */
+  createNode(id, attributes) {
+    const node = new Node(id, attributes);
+    this.#objects.nodes.set(id, node);
+    return node;
+  }
+  /**
+   * Get Subgraph in cluster by specifying id.
+   *
+   * If there is no Subgraph with the specified id in the cluster, return undefined.
+   */
+  getSubgraph(id) {
+    return Array.from(this.#objects.subgraphs.values()).find((subgraph) => subgraph.id === id);
+  }
+  /**EdgeAttributesObject
+   * Get Node in cluster by specifying id.
+   *
+   * @description
+   * If there is no Node with the specified id in the cluster, return undefined.
+   */
+  getNode(id) {
+    return this.#objects.nodes.get(id);
+  }
+  /** Create Edge and add it to the cluster. */
+  createEdge(targets, attributes) {
+    const ts = targets.map((t) => (isNodeRefGroupLike(t) ? toNodeRefGroup(t) : toNodeRef(t)));
+    const edge = new Edge(ts, attributes);
+    this.#objects.edges.add(edge);
+    return edge;
+  }
+  subgraph(...args) {
+    const id = args.find((arg) => typeof arg === 'string');
+    const attributes = args.find((arg) => typeof arg === 'object' && arg !== null);
+    const callback = args.find((arg) => typeof arg === 'function');
+    const subgraph = id ? this.getSubgraph(id) ?? this.createSubgraph(id) : this.createSubgraph();
+    if (attributes !== undefined) {
+      subgraph.apply(attributes);
+    }
+    if (callback !== undefined) {
+      callback(subgraph);
+    }
+    return subgraph;
+  }
+  node(firstArg, ...args) {
+    if (typeof firstArg === 'string') {
+      const id = firstArg;
+      const attributes = args.find((arg) => typeof arg === 'object' && arg !== null);
+      const callback = args.find((arg) => typeof arg === 'function');
+      const node = this.getNode(id) ?? this.createNode(id);
+      if (attributes !== undefined) {
+        node.attributes.apply(attributes);
+      }
+      if (callback !== undefined) {
+        callback(node);
+      }
+      return node;
+    }
+    if (typeof firstArg === 'object' && firstArg !== null) {
+      this.attributes.node.apply(firstArg);
+    }
+  }
+  edge(firstArg, ...args) {
+    if (Array.isArray(firstArg)) {
+      const targets = firstArg;
+      const attributes = args.find((arg) => typeof arg === 'object');
+      const callback = args.find((arg) => typeof arg === 'function');
+      const edge = this.createEdge(targets, attributes);
+      if (callback !== undefined) {
+        callback(edge);
+      }
+      return edge;
+    }
+    if (typeof firstArg === 'object' && firstArg !== null) {
+      this.attributes.edge.apply(firstArg);
+    }
+  }
+  /**
+   * Set a common attribute for the clusters in the cluster.
+   *
+   * ```ts
+   * 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",
+   * //   ];
+   * // }
+   * ```
+   * @param attributes Object of attributes to be adapted to the clusters.
+   */
+  graph(attributes) {
+    this.attributes.graph.apply(attributes);
+  }
+}
+/**
+ * Subgraph object.
+ */
+class Subgraph extends GraphBase {
+  get $$type() {
+    return 'Subgraph';
+  }
+  id;
+  attributes = Object.freeze({
+    graph: new AttributeList('Graph'),
+    edge: new AttributeList('Edge'),
+    node: new AttributeList('Node'),
+  });
+  constructor(...args) {
+    super();
+    this.id = args.find((arg) => typeof arg === 'string');
+    const attributes = args.find((arg) => typeof arg === 'object' && arg !== null);
+    if (attributes !== undefined) {
+      this.apply(attributes);
+    }
+  }
+  /** Determines whether the Subgraph is a SubgraphCluster. */
+  isSubgraphCluster() {
+    if (typeof this.id === 'string') {
+      return this.id.startsWith('cluster');
+    }
+    return false;
+  }
+}
+/**
+ * Node object.
+ */
+class Node extends DotObject {
+  id;
+  get $$type() {
+    return 'Node';
+  }
+  /** Comments to include when outputting with toDot. */
+  comment;
+  attributes;
+  constructor(id, attributes) {
+    super();
+    this.id = id;
+    this.attributes = new AttributesGroupModel(attributes);
+  }
+  /** Returns ForwardRefNode with port and compass specified. */
+  port(port) {
+    if (typeof port === 'string') {
+      return { id: this.id, port };
+    }
+    return { id: this.id, ...port };
+  }
+}
+/**
+ */
+class Edge extends DotObject {
+  targets;
+  get $$type() {
+    return 'Edge';
+  }
+  /** Comments to include when outputting with toDot. */
+  comment;
+  attributes;
+  constructor(targets, attributes) {
+    super();
+    this.targets = targets;
+    if (targets.length < 2 && (isNodeRefLike(targets[0]) && isNodeRefLike(targets[1])) === false) {
+      throw Error('The element of Edge target is missing or not satisfied as Edge target.');
+    }
+    this.attributes = new AttributesGroupModel(attributes);
+  }
+}
+/**
+ * Base class for RootGraph.
+ *
+ */
+class RootGraph extends GraphBase {
+  get $$type() {
+    return 'Graph';
+  }
+  id;
+  /**
+   * Strict mode.
+   *
+   * @description
+   * 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.
+   */
+  strict;
+  attributes = Object.freeze({
+    graph: new AttributeList('Graph'),
+    edge: new AttributeList('Edge'),
+    node: new AttributeList('Node'),
+  });
+  constructor(...args) {
+    super();
+    this.id = args.find((arg) => typeof arg === 'string');
+    this.strict = args.find((arg) => typeof arg === 'boolean') ?? false;
+    const attributes = args.find((arg) => typeof arg === 'object' && arg !== null);
+    if (attributes !== undefined) {
+      this.apply(attributes);
+    }
+  }
+}
+class Graph extends RootGraph {
+  get directed() {
+    return false;
+  }
+}
+class Digraph extends RootGraph {
+  get directed() {
+    return true;
+  }
+}
+
+/** @hidden */
+function builder(directed, strictMode) {
+  const C = directed ? Digraph : Graph;
+  return (...args) => {
+    const id = args.find((arg) => typeof arg === 'string');
+    const attributes = args.find((arg) => typeof arg === 'object');
+    const callback = args.find((arg) => typeof arg === 'function');
+    const g = new C(id, strictMode, attributes);
+    if (typeof callback === 'function') {
+      callback(g);
+    }
+    return g;
+  };
+}
+/** API for creating directional graph objects. */
+const digraph = builder(true, false);
+/** API for creating omnidirectional graph objects. */
+const graph = builder(false, false);
+/** Provides a strict mode API. */
+const strict = Object.freeze({
+  /** API for creating directional graph objects in strict mode. */
+  digraph: builder(true, true),
+  /** API for creating omnidirectional graph objects in strict mode. */
+  graph: builder(false, true),
+});
+
+function toDot(model, options) {
+  const ast = fromModel(model, options?.convert);
+  return stringify(ast, options?.print);
+}
+
+export {
+  AttributeList,
+  AttributesBase,
+  AttributesGroupModel,
+  Digraph,
+  DotObject,
+  Edge,
+  Graph,
+  GraphBase,
+  GraphvizObject,
+  Node,
+  RootGraph,
+  Subgraph,
+  attribute,
+  digraph,
+  graph,
+  strict,
+  toDot,
+};

package/lib/index.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var common = require('#/lib/common');
+var core = require('#/lib/core');
+
+Object.keys(common).forEach(function (k) {
+  if (k !== 'default' && !exports.hasOwnProperty(k))
+    Object.defineProperty(exports, k, {
+      enumerable: true,
+      get: function () {
+        return common[k];
+      },
+    });
+});
+Object.keys(core).forEach(function (k) {
+  if (k !== 'default' && !exports.hasOwnProperty(k))
+    Object.defineProperty(exports, k, {
+      enumerable: true,
+      get: function () {
+        return core[k];
+      },
+    });
+});