upgrade ts-graphviz@0.16.0

Author: kamiazya

.denolized

@@ -4,6 +4,7 @@ render/utils.ts
 render/renderer.ts
 types.ts
 model/nodes.ts
+model/utils.ts
 model/edges.ts
 model/root_clusters.ts
 model/clusters.ts

model/clusters.ts

@@ -2,12 +2,9 @@
 import { attribute } from "../attribute.ts";
 import {
   ClusterSubgraphAttributes,
-  Compass,
   EdgeAttributes,
-  EdgeTarget,
-  EdgeTargetLike,
-  EdgeTargets,
-  EdgeTargetsLike,
+  EdgeTargetLikeTuple,
+  EdgeTargetTuple,
   ICluster,
   IClusterCommonAttributes,
   IEdge,
@@ -16,13 +13,9 @@ import {
   NodeAttributes,
 } from "../types.ts";
 import { Attributes, AttributesBase } from "./attributes_base.ts";
-import {
-  isEdgeTarget,
-  isEdgeTargetLike,
-  isEdgeTargetsLike,
-  Node,
-} from "./nodes.ts";
+import { Node } from "./nodes.ts";
 import { Edge } from "./edges.ts";
+import { isNodeRefGroupLike, toNodeRef, toNodeRefGroup } from "./utils.ts";
 /**
  * Base class for clusters.
  * @hidden
@@ -165,49 +158,19 @@ export abstract class Cluster<T extends string> extends AttributesBase<T>
   }
   /** Create Edge and add it to the cluster. */
   public createEdge(
-    targets: (EdgeTargetLike | EdgeTargetsLike)[],
+    targets: EdgeTargetLikeTuple,
     attributes?: EdgeAttributes,
   ): IEdge {
-    const edge = new Edge(
-      targets.map((
-        t,
-      ) => (isEdgeTargetsLike(t)
-        ? this.toEdgeTargets(t)
-        : this.toEdgeTarget(t))
-      ),
-      attributes,
-    );
+    const ts = targets.map((
+      t,
+    ) => (isNodeRefGroupLike(t)
+      ? toNodeRefGroup(t)
+      : toNodeRef(t))
+    ) as EdgeTargetTuple;
+    const edge = new Edge(ts, attributes);
     this.objects.edges.add(edge);
     return edge;
   }
-  /** @hidden */
-  private toEdgeTarget(target: EdgeTargetLike): EdgeTarget {
-    if (isEdgeTarget(target)) {
-      return target;
-    }
-    const [id, port, compass] = target.split(":");
-    const n = this.getNode(id);
-    if (n !== undefined) {
-      if (port && (compass === undefined || Compass.is(compass))) {
-        return n.port({ port, compass });
-      }
-      return n;
-    }
-    if (Compass.is(compass)) {
-      return { id, port, compass };
-    }
-    return { id, port };
-  }
-  /** @hidden */
-  private toEdgeTargets(targets: EdgeTargetsLike): EdgeTargets {
-    if (
-      targets.length < 2 &&
-      (isEdgeTargetLike(targets[0]) && isEdgeTargetLike(targets[1])) === false
-    ) {
-      throw Error("EdgeTargets must have at least 2 elements.");
-    }
-    return targets.map((t) => this.toEdgeTarget(t));
-  }
   /**
      * Create a subgraph by specifying its id (or get it if it already exists).
      *
@@ -450,7 +413,7 @@ export abstract class Cluster<T extends string> extends AttributesBase<T>
      * @param callback Callbacks for manipulating created or retrieved edge.
      */
   public edge(
-    targets: EdgeTargetLike[],
+    targets: EdgeTargetLikeTuple,
     callback?: (edge: IEdge) => void,
   ): IEdge;
   /**
@@ -481,7 +444,7 @@ export abstract class Cluster<T extends string> extends AttributesBase<T>
      * @param callback Callbacks for manipulating created or retrieved edge.
      */
   public edge(
-    targets: EdgeTargetLike[],
+    targets: EdgeTargetLikeTuple,
     attributes: EdgeAttributes,
     callback?: (edge: IEdge) => void,
   ): IEdge;
@@ -510,11 +473,11 @@ export abstract class Cluster<T extends string> extends AttributesBase<T>
      */
   public edge(attributes: EdgeAttributes): void;
   public edge(
-    firstArg: EdgeTargetLike[] | EdgeAttributes,
+    firstArg: EdgeTargetLikeTuple | EdgeAttributes,
     ...args: unknown[]
   ): IEdge | void {
     if (Array.isArray(firstArg)) {
-      const targets = [...firstArg];
+      const targets = firstArg;
       const attributes = args.find((arg: unknown): arg is EdgeAttributes =>
         typeof arg === "object"
       );
@@ -574,7 +537,7 @@ export class Subgraph
     super();
     this.id = args.find((arg): arg is string => typeof arg === "string");
     const attributes = args.find((arg): arg is ClusterSubgraphAttributes =>
-      typeof arg === "object"
+      typeof arg === "object" && arg !== null
     );
     if (attributes !== undefined) {
       this.apply(attributes);

model/edges.ts

@@ -1,28 +1,28 @@
 import {
   EdgeAttributes,
-  EdgeTarget,
-  EdgeTargets,
+  EdgeTargetTuple,
   IAttributes,
+  IEdge,
 } from "../types.ts";
 import { DotObject } from "./abstract.ts";
 import { attribute } from "../attribute.ts";
 import { Attributes } from "./attributes_base.ts";
-import { isEdgeTargetLike } from "./nodes.ts";
+import { isNodeRefLike } from "./utils.ts";
 /**
  * @category Primary
  */
-export class Edge extends DotObject {
+export class Edge extends DotObject implements IEdge {
   /** Comments to include when outputting with toDot. */
   public comment?: string;
   public readonly attributes: IAttributes<attribute.Edge>;
   constructor(
-    public readonly targets: ReadonlyArray<EdgeTarget | EdgeTargets>,
+    public readonly targets: EdgeTargetTuple,
     attributes?: EdgeAttributes,
   ) {
     super();
     if (
       targets.length < 2 &&
-      (isEdgeTargetLike(targets[0]) && isEdgeTargetLike(targets[1])) === false
+      (isNodeRefLike(targets[0]) && isNodeRefLike(targets[1])) === false
     ) {
       throw Error(
         "The element of Edge target is missing or not satisfied as Edge target.",

model/nodes.ts

@@ -1,6 +1,4 @@
 import {
-  EdgeTarget,
-  EdgeTargetLike,
   IAttributes,
   IForwardRefNode,
   INode,
@@ -10,7 +8,6 @@ import {
 import { DotObject } from "./abstract.ts";
 import { attribute } from "../attribute.ts";
 import { Attributes } from "./attributes_base.ts";
-import { EdgeTargetsLike } from "../types.ts";
 /**
  * Node object.
  * @category Primary
@@ -31,27 +28,3 @@ export class Node extends DotObject implements INode {
     return { id: this.id, ...port };
   }
 }
-export function isForwardRefNode(object: unknown): object is IForwardRefNode {
-  return typeof object == "object" && object !== null &&
-    typeof (object as IForwardRefNode).id === "string";
-}
-/**
- * @hidden
- */
-export function isEdgeTarget(node: unknown): node is EdgeTarget {
-  return node instanceof Node || isForwardRefNode(node);
-}
-/**
- * @hidden
- */
-export function isEdgeTargetLike(node: unknown): node is EdgeTargetLike {
-  return typeof node === "string" || isEdgeTarget(node);
-}
-/**
- * @hidden
- */
-export function isEdgeTargetsLike(
-  target: EdgeTargetLike | EdgeTargetsLike,
-): target is EdgeTargetsLike {
-  return Array.isArray(target) && target.every(isEdgeTargetLike);
-}

model/utils.ts

@@ -0,0 +1,49 @@
+import {
+  Compass,
+  IForwardRefNode,
+  NodeRef,
+  NodeRefGroup,
+  NodeRefGroupLike,
+  NodeRefLike,
+} from "../types.ts";
+import { Node } from "./nodes.ts";
+/** @hidden */
+export function isForwardRefNode(object: unknown): object is IForwardRefNode {
+  return typeof object == "object" && object !== null &&
+    typeof (object as IForwardRefNode).id === "string";
+}
+/** @hidden */
+export function isNodeRef(node: unknown): node is NodeRef {
+  return node instanceof Node || isForwardRefNode(node);
+}
+/** @hidden */
+export function isNodeRefLike(node: unknown): node is NodeRefLike {
+  return typeof node === "string" || isNodeRef(node);
+}
+/** @hidden */
+export function isNodeRefGroupLike(
+  target: NodeRefLike | NodeRefGroupLike,
+): target is NodeRefGroupLike {
+  return Array.isArray(target) && target.every(isNodeRefLike);
+}
+/** @hidden */
+export function toNodeRef(target: NodeRefLike): NodeRef {
+  if (isNodeRef(target)) {
+    return target;
+  }
+  const [id, port, compass] = target.split(":");
+  if (Compass.is(compass)) {
+    return { id, port, compass };
+  }
+  return { id, port };
+}
+/** @hidden */
+export function toNodeRefGroup(targets: NodeRefGroupLike): NodeRefGroup {
+  if (
+    targets.length < 2 &&
+    (isNodeRefLike(targets[0]) && isNodeRefLike(targets[1])) === false
+  ) {
+    throw Error("EdgeTargets must have at least 2 elements.");
+  }
+  return targets.map((t) => toNodeRef(t));
+}

render/renderer.ts

@@ -6,8 +6,8 @@ import {
   IRootCluster,
   ISubgraph,
 } from "../types.ts";
-import { isEdgeTargetLike } from "../model/nodes.ts";
-import { renderEdgeTargets } from "./utils.ts";
+import { isNodeRef } from "../model/utils.ts";
+import { renderNodeRefGroup } from "./utils.ts";
 import {
   commentOutIfExist,
   concatWordsWithSpace,
@@ -25,14 +25,14 @@ import {
   renderAttributeValue,
   renderAttributeWithSemi,
   renderClusterType,
-  renderEdgeTarget,
+  renderNodeRef,
   spaceLeftPad,
 } from "./utils.ts";
 export class Renderer {
   private root?: IRootCluster;
   protected renderNode(node: INode): string {
     const comment = commentOutIfExist(node.comment);
-    const target = renderEdgeTarget(node);
+    const target = renderNodeRef(node);
     const attrs = node.attributes.size > 0
       ? spaceLeftPad(renderAttributes(node.attributes))
       : undefined;
@@ -45,7 +45,7 @@ export class Renderer {
       isGraph(this.root) ? " -- " : " -> ",
       edge.targets.map((
         t,
-      ) => (isEdgeTargetLike(t) ? renderEdgeTarget(t) : renderEdgeTargets(t))),
+      ) => (isNodeRef(t) ? renderNodeRef(t) : renderNodeRefGroup(t))),
     );
     const attrs = edge.attributes.size > 0
       ? spaceLeftPad(renderAttributes(edge.attributes))

render/utils.ts

@@ -1,19 +1,20 @@
 import {
   AttributesValue,
-  EdgeTarget,
-  EdgeTargets,
   IAttributes,
   ICluster,
   IEdge,
   INode,
   IRootCluster,
   ISubgraph,
+  NodeRef,
+  NodeRefGroup,
 } from "../types.ts";
 import { Subgraph } from "../model/clusters.ts";
 import { Edge } from "../model/edges.ts";
-import { isForwardRefNode, Node } from "../model/nodes.ts";
+import { Node } from "../model/nodes.ts";
 import { Digraph, Graph, RootCluster } from "../model/root_clusters.ts";
 import { Attributes } from "../model/attributes_base.ts";
+import { isForwardRefNode } from "../model/utils.ts";
 export function escape(str: string): string {
   return str.replace(/\n/g, "\\n").replace(/"/g, '\\"');
 }
@@ -154,21 +155,18 @@ export function renderAttributes(attributes: IAttributes): string {
     "]",
   );
 }
-export function renderEdgeTarget(edgeTarget: EdgeTarget): string | undefined {
-  if (isNode(edgeTarget)) {
-    return renderAttributeValue(edgeTarget.id);
-  } else if (isForwardRefNode(edgeTarget)) {
-    const port = edgeTarget.port;
-    const compass = edgeTarget.compass;
+export function renderNodeRef(node: NodeRef): string | undefined {
+  if (isNode(node)) {
+    return renderAttributeValue(node.id);
+  } else if (isForwardRefNode(node)) {
+    const { id, port, compass } = node;
     return concatWordsWithColon(
-      renderAttributeValue(edgeTarget.id),
+      renderAttributeValue(id),
       port !== undefined ? renderAttributeValue(port) : undefined,
       compass !== undefined ? renderAttributeValue(compass) : undefined,
     );
   }
 }
-export function renderEdgeTargets(
-  edgeTargets: EdgeTargets,
-): string | undefined {
-  return "{" + concatWordsWithSpace(...edgeTargets.map(renderEdgeTarget)) + "}";
+export function renderNodeRefGroup(group: NodeRefGroup): string | undefined {
+  return "{" + concatWordsWithSpace(...group.map(renderNodeRef)) + "}";
 }