@ts-graphviz/core 0.0.0-next-20240301111950

package/lib/Digraph.d.ts

@@ -0,0 +1,107 @@
+import { Attribute } from '@ts-graphviz/common';
+import { AttributeKey } from '@ts-graphviz/common';
+import { Attributes } from '@ts-graphviz/common';
+import { AttributesEntities } from '@ts-graphviz/common';
+import { AttributesObject } from '@ts-graphviz/common';
+import { EdgeAttributesObject } from '@ts-graphviz/common';
+import { EdgeModel } from '@ts-graphviz/common';
+import { EdgeTargetLikeTuple } from '@ts-graphviz/common';
+import { GraphAttributeKey } from '@ts-graphviz/common';
+import { GraphAttributesObject } from '@ts-graphviz/common';
+import { GraphBaseModel } from '@ts-graphviz/common';
+import { GraphCommonAttributes } from '@ts-graphviz/common';
+import { ModelsContext } from '@ts-graphviz/common';
+import { NodeAttributesObject } from '@ts-graphviz/common';
+import { NodeModel } from '@ts-graphviz/common';
+import { RootGraphModel } from '@ts-graphviz/common';
+import { SubgraphAttributesObject } from '@ts-graphviz/common';
+import { SubgraphModel } from '@ts-graphviz/common';
+
+/**
+ * Base class for DOT objects with attributes.
+ * @group Models
+ */
+declare abstract class AttributesBase<T extends AttributeKey> extends DotObject implements Attributes<T> {
+    #private;
+    constructor(attributes?: AttributesObject<T>);
+    get values(): ReadonlyArray<[T, Attribute<T>]>;
+    get size(): number;
+    get<K extends T>(key: K): Attribute<K> | undefined;
+    set<K extends T>(key: K, value: Attribute<K>): void;
+    delete(key: T): void;
+    apply(attributes: AttributesObject<T> | AttributesEntities<T>): void;
+    clear(): void;
+}
+
+/**
+ * DOT object class representing a digraph.
+ * @group Models
+ */
+export declare class Digraph extends RootGraph {
+    get directed(): boolean;
+}
+
+/**
+ * Base class for DOT objects.
+ * @group Models
+ */
+declare abstract class DotObject {
+}
+
+/**
+ * Base class for Graph objects.
+ * @group Models
+ */
+declare abstract class GraphBase<T extends AttributeKey> extends AttributesBase<T> implements GraphBaseModel<T> {
+    #private;
+    readonly id?: string;
+    comment?: string;
+    readonly attributes: Readonly<GraphCommonAttributes>;
+    get nodes(): ReadonlyArray<NodeModel>;
+    get edges(): ReadonlyArray<EdgeModel>;
+    get subgraphs(): ReadonlyArray<SubgraphModel>;
+    with(models: Partial<ModelsContext>): void;
+    addNode(node: NodeModel): void;
+    addEdge(edge: EdgeModel): void;
+    addSubgraph(subgraph: SubgraphModel): void;
+    existNode(nodeId: string): boolean;
+    existEdge(edge: EdgeModel): boolean;
+    existSubgraph(subgraph: SubgraphModel): boolean;
+    createSubgraph(id?: string, attributes?: SubgraphAttributesObject): SubgraphModel;
+    createSubgraph(attributes?: SubgraphAttributesObject): SubgraphModel;
+    removeNode(node: NodeModel | string): void;
+    removeEdge(edge: EdgeModel): void;
+    removeSubgraph(subgraph: SubgraphModel): void;
+    createNode(id: string, attributes?: NodeAttributesObject): NodeModel;
+    getSubgraph(id: string): SubgraphModel | undefined;
+    getNode(id: string): NodeModel | undefined;
+    createEdge(targets: EdgeTargetLikeTuple, attributes?: EdgeAttributesObject): EdgeModel;
+    subgraph(id: string, callback?: (subgraph: SubgraphModel) => void): SubgraphModel;
+    subgraph(id: string, attributes: SubgraphAttributesObject, callback?: (subgraph: SubgraphModel) => void): SubgraphModel;
+    subgraph(attributes: SubgraphAttributesObject, callback?: (subgraph: SubgraphModel) => void): SubgraphModel;
+    subgraph(callback?: (subgraph: SubgraphModel) => void): SubgraphModel;
+    node(id: string, callback?: (node: NodeModel) => void): NodeModel;
+    node(id: string, attributes: NodeAttributesObject, callback?: (node: NodeModel) => void): NodeModel;
+    node(attributes: NodeAttributesObject): void;
+    edge(targets: EdgeTargetLikeTuple, callback?: (edge: EdgeModel) => void): EdgeModel;
+    edge(targets: EdgeTargetLikeTuple, attributes: EdgeAttributesObject, callback?: (edge: EdgeModel) => void): EdgeModel;
+    edge(attributes: EdgeAttributesObject): void;
+    graph(attributes: SubgraphAttributesObject): void;
+}
+
+/**
+ * Base class representing a root graph(digraph, graph).
+ * @group Models
+ */
+declare abstract class RootGraph extends GraphBase<GraphAttributeKey> implements RootGraphModel {
+    get $$type(): 'Graph';
+    readonly id?: string;
+    abstract readonly directed: boolean;
+    strict: boolean;
+    constructor(id?: string, attributes?: GraphAttributesObject);
+    constructor(id?: string, strict?: boolean, attributes?: GraphAttributesObject);
+    constructor(strict?: boolean, attributes?: GraphAttributesObject);
+    constructor(attributes?: GraphAttributesObject);
+}
+
+export { }

package/lib/Digraph.js

@@ -0,0 +1,9 @@
+import { RootGraph } from "./RootGraph.js";
+class Digraph extends RootGraph {
+  get directed() {
+    return true;
+  }
+}
+export {
+  Digraph
+};

package/lib/DotObject.cjs

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+class DotObject {
+}
+exports.DotObject = DotObject;

package/lib/DotObject.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Base class for DOT objects.
+ * @group Models
+ */
+export declare abstract class DotObject {
+}
+
+export { }

package/lib/DotObject.js

@@ -0,0 +1,5 @@
+class DotObject {
+}
+export {
+  DotObject
+};

package/lib/Edge.cjs

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const common = require("@ts-graphviz/common");
+const AttributesGroup = require("./AttributesGroup.cjs");
+const DotObject = require("./DotObject.cjs");
+class Edge extends DotObject.DotObject {
+  constructor(targets, attributes) {
+    super();
+    this.targets = targets;
+    if (targets.length < 2 && (common.isNodeRefLike(targets[0]) && common.isNodeRefLike(targets[1])) === false) {
+      throw Error(
+        "The element of Edge target is missing or not satisfied as Edge target."
+      );
+    }
+    this.attributes = new AttributesGroup.AttributesGroup(attributes);
+  }
+  get $$type() {
+    return "Edge";
+  }
+  comment;
+  attributes;
+}
+exports.Edge = Edge;

package/lib/Edge.d.ts

@@ -0,0 +1,26 @@
+import { AttributesGroupModel } from '@ts-graphviz/common';
+import { EdgeAttributeKey } from '@ts-graphviz/common';
+import { EdgeAttributesObject } from '@ts-graphviz/common';
+import { EdgeModel } from '@ts-graphviz/common';
+import { EdgeTargetTuple } from '@ts-graphviz/common';
+
+/**
+ * Base class for DOT objects.
+ * @group Models
+ */
+declare abstract class DotObject {
+}
+
+/**
+ * DOT object class representing a edge.
+ * @group Models
+ */
+export declare class Edge extends DotObject implements EdgeModel {
+    readonly targets: EdgeTargetTuple;
+    get $$type(): 'Edge';
+    comment?: string;
+    readonly attributes: AttributesGroupModel<EdgeAttributeKey>;
+    constructor(targets: EdgeTargetTuple, attributes?: EdgeAttributesObject);
+}
+
+export { }

package/lib/Edge.js

@@ -0,0 +1,23 @@
+import { isNodeRefLike } from "@ts-graphviz/common";
+import { AttributesGroup } from "./AttributesGroup.js";
+import { DotObject } from "./DotObject.js";
+class Edge extends DotObject {
+  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 AttributesGroup(attributes);
+  }
+  get $$type() {
+    return "Edge";
+  }
+  comment;
+  attributes;
+}
+export {
+  Edge
+};

package/lib/Graph.cjs

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const RootGraph = require("./RootGraph.cjs");
+class Graph extends RootGraph.RootGraph {
+  get directed() {
+    return false;
+  }
+}
+exports.Graph = Graph;

package/lib/Graph.d.ts

@@ -0,0 +1,107 @@
+import { Attribute } from '@ts-graphviz/common';
+import { AttributeKey } from '@ts-graphviz/common';
+import { Attributes } from '@ts-graphviz/common';
+import { AttributesEntities } from '@ts-graphviz/common';
+import { AttributesObject } from '@ts-graphviz/common';
+import { EdgeAttributesObject } from '@ts-graphviz/common';
+import { EdgeModel } from '@ts-graphviz/common';
+import { EdgeTargetLikeTuple } from '@ts-graphviz/common';
+import { GraphAttributeKey } from '@ts-graphviz/common';
+import { GraphAttributesObject } from '@ts-graphviz/common';
+import { GraphBaseModel } from '@ts-graphviz/common';
+import { GraphCommonAttributes } from '@ts-graphviz/common';
+import { ModelsContext } from '@ts-graphviz/common';
+import { NodeAttributesObject } from '@ts-graphviz/common';
+import { NodeModel } from '@ts-graphviz/common';
+import { RootGraphModel } from '@ts-graphviz/common';
+import { SubgraphAttributesObject } from '@ts-graphviz/common';
+import { SubgraphModel } from '@ts-graphviz/common';
+
+/**
+ * Base class for DOT objects with attributes.
+ * @group Models
+ */
+declare abstract class AttributesBase<T extends AttributeKey> extends DotObject implements Attributes<T> {
+    #private;
+    constructor(attributes?: AttributesObject<T>);
+    get values(): ReadonlyArray<[T, Attribute<T>]>;
+    get size(): number;
+    get<K extends T>(key: K): Attribute<K> | undefined;
+    set<K extends T>(key: K, value: Attribute<K>): void;
+    delete(key: T): void;
+    apply(attributes: AttributesObject<T> | AttributesEntities<T>): void;
+    clear(): void;
+}
+
+/**
+ * Base class for DOT objects.
+ * @group Models
+ */
+declare abstract class DotObject {
+}
+
+/**
+ * DOT object class representing a graph.
+ * @group Models
+ */
+export declare class Graph extends RootGraph {
+    get directed(): boolean;
+}
+
+/**
+ * Base class for Graph objects.
+ * @group Models
+ */
+declare abstract class GraphBase<T extends AttributeKey> extends AttributesBase<T> implements GraphBaseModel<T> {
+    #private;
+    readonly id?: string;
+    comment?: string;
+    readonly attributes: Readonly<GraphCommonAttributes>;
+    get nodes(): ReadonlyArray<NodeModel>;
+    get edges(): ReadonlyArray<EdgeModel>;
+    get subgraphs(): ReadonlyArray<SubgraphModel>;
+    with(models: Partial<ModelsContext>): void;
+    addNode(node: NodeModel): void;
+    addEdge(edge: EdgeModel): void;
+    addSubgraph(subgraph: SubgraphModel): void;
+    existNode(nodeId: string): boolean;
+    existEdge(edge: EdgeModel): boolean;
+    existSubgraph(subgraph: SubgraphModel): boolean;
+    createSubgraph(id?: string, attributes?: SubgraphAttributesObject): SubgraphModel;
+    createSubgraph(attributes?: SubgraphAttributesObject): SubgraphModel;
+    removeNode(node: NodeModel | string): void;
+    removeEdge(edge: EdgeModel): void;
+    removeSubgraph(subgraph: SubgraphModel): void;
+    createNode(id: string, attributes?: NodeAttributesObject): NodeModel;
+    getSubgraph(id: string): SubgraphModel | undefined;
+    getNode(id: string): NodeModel | undefined;
+    createEdge(targets: EdgeTargetLikeTuple, attributes?: EdgeAttributesObject): EdgeModel;
+    subgraph(id: string, callback?: (subgraph: SubgraphModel) => void): SubgraphModel;
+    subgraph(id: string, attributes: SubgraphAttributesObject, callback?: (subgraph: SubgraphModel) => void): SubgraphModel;
+    subgraph(attributes: SubgraphAttributesObject, callback?: (subgraph: SubgraphModel) => void): SubgraphModel;
+    subgraph(callback?: (subgraph: SubgraphModel) => void): SubgraphModel;
+    node(id: string, callback?: (node: NodeModel) => void): NodeModel;
+    node(id: string, attributes: NodeAttributesObject, callback?: (node: NodeModel) => void): NodeModel;
+    node(attributes: NodeAttributesObject): void;
+    edge(targets: EdgeTargetLikeTuple, callback?: (edge: EdgeModel) => void): EdgeModel;
+    edge(targets: EdgeTargetLikeTuple, attributes: EdgeAttributesObject, callback?: (edge: EdgeModel) => void): EdgeModel;
+    edge(attributes: EdgeAttributesObject): void;
+    graph(attributes: SubgraphAttributesObject): void;
+}
+
+/**
+ * Base class representing a root graph(digraph, graph).
+ * @group Models
+ */
+declare abstract class RootGraph extends GraphBase<GraphAttributeKey> implements RootGraphModel {
+    get $$type(): 'Graph';
+    readonly id?: string;
+    abstract readonly directed: boolean;
+    strict: boolean;
+    constructor(id?: string, attributes?: GraphAttributesObject);
+    constructor(id?: string, strict?: boolean, attributes?: GraphAttributesObject);
+    constructor(strict?: boolean, attributes?: GraphAttributesObject);
+    constructor(attributes?: GraphAttributesObject);
+}
+
+export { }

package/lib/Graph.js

@@ -0,0 +1,9 @@
+import { RootGraph } from "./RootGraph.js";
+class Graph extends RootGraph {
+  get directed() {
+    return false;
+  }
+}
+export {
+  Graph
+};

package/lib/GraphBase.cjs

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const common = require("@ts-graphviz/common");
+const AttributeList = require("./AttributeList.cjs");
+const AttributesBase = require("./AttributesBase.cjs");
+class GraphBase extends AttributesBase.AttributesBase {
+  /** @hidden */
+  #models = common.RootModelsContext;
+  id;
+  comment;
+  attributes = Object.freeze({
+    graph: new AttributeList.AttributeList("Graph"),
+    edge: new AttributeList.AttributeList("Edge"),
+    node: new AttributeList.AttributeList("Node")
+  });
+  get nodes() {
+    return Array.from(this.#objects.nodes.values());
+  }
+  get edges() {
+    return Array.from(this.#objects.edges.values());
+  }
+  get subgraphs() {
+    return Array.from(this.#objects.subgraphs.values());
+  }
+  /** @hidden */
+  #objects = {
+    nodes: /* @__PURE__ */ new Map(),
+    edges: /* @__PURE__ */ new Set(),
+    subgraphs: /* @__PURE__ */ new Set()
+  };
+  with(models) {
+    this.#models = common.createModelsContext(models);
+  }
+  addNode(node) {
+    this.#objects.nodes.set(node.id, node);
+  }
+  addEdge(edge) {
+    this.#objects.edges.add(edge);
+  }
+  addSubgraph(subgraph) {
+    this.#objects.subgraphs.add(subgraph);
+  }
+  existNode(nodeId) {
+    return this.#objects.nodes.has(nodeId);
+  }
+  existEdge(edge) {
+    return this.#objects.edges.has(edge);
+  }
+  existSubgraph(subgraph) {
+    return this.#objects.subgraphs.has(subgraph);
+  }
+  createSubgraph(...args) {
+    const subgraph = new this.#models.Subgraph(...args);
+    subgraph.with(this.#models);
+    this.addSubgraph(subgraph);
+    return subgraph;
+  }
+  removeNode(node) {
+    this.#objects.nodes.delete(typeof node === "string" ? node : node.id);
+  }
+  removeEdge(edge) {
+    this.#objects.edges.delete(edge);
+  }
+  removeSubgraph(subgraph) {
+    this.#objects.subgraphs.delete(subgraph);
+  }
+  createNode(id, attributes) {
+    const node = new this.#models.Node(id, attributes);
+    this.addNode(node);
+    return node;
+  }
+  getSubgraph(id) {
+    return Array.from(this.#objects.subgraphs.values()).find(
+      (subgraph) => subgraph.id === id
+    );
+  }
+  getNode(id) {
+    return this.#objects.nodes.get(id);
+  }
+  createEdge(targets, attributes) {
+    const ts = targets.map(
+      (t) => common.isNodeRefGroupLike(t) ? common.toNodeRefGroup(t) : common.toNodeRef(t)
+    );
+    const edge = new this.#models.Edge(ts, attributes);
+    this.addEdge(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 !== void 0) {
+      subgraph.apply(attributes);
+    }
+    if (callback !== void 0) {
+      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 !== void 0) {
+        node.attributes.apply(attributes);
+      }
+      if (callback !== void 0) {
+        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 !== void 0) {
+        callback(edge);
+      }
+      return edge;
+    }
+    if (typeof firstArg === "object" && firstArg !== null) {
+      this.attributes.edge.apply(firstArg);
+    }
+  }
+  graph(attributes) {
+    this.attributes.graph.apply(attributes);
+  }
+}
+exports.GraphBase = GraphBase;

package/lib/GraphBase.d.ts

@@ -0,0 +1,81 @@
+import { Attribute } from '@ts-graphviz/common';
+import { AttributeKey } from '@ts-graphviz/common';
+import { Attributes } from '@ts-graphviz/common';
+import { AttributesEntities } from '@ts-graphviz/common';
+import { AttributesObject } from '@ts-graphviz/common';
+import { EdgeAttributesObject } from '@ts-graphviz/common';
+import { EdgeModel } from '@ts-graphviz/common';
+import { EdgeTargetLikeTuple } from '@ts-graphviz/common';
+import { GraphBaseModel } from '@ts-graphviz/common';
+import { GraphCommonAttributes } from '@ts-graphviz/common';
+import { ModelsContext } from '@ts-graphviz/common';
+import { NodeAttributesObject } from '@ts-graphviz/common';
+import { NodeModel } from '@ts-graphviz/common';
+import { SubgraphAttributesObject } from '@ts-graphviz/common';
+import { SubgraphModel } from '@ts-graphviz/common';
+
+/**
+ * Base class for DOT objects with attributes.
+ * @group Models
+ */
+declare abstract class AttributesBase<T extends AttributeKey> extends DotObject implements Attributes<T> {
+    #private;
+    constructor(attributes?: AttributesObject<T>);
+    get values(): ReadonlyArray<[T, Attribute<T>]>;
+    get size(): number;
+    get<K extends T>(key: K): Attribute<K> | undefined;
+    set<K extends T>(key: K, value: Attribute<K>): void;
+    delete(key: T): void;
+    apply(attributes: AttributesObject<T> | AttributesEntities<T>): void;
+    clear(): void;
+}
+
+/**
+ * Base class for DOT objects.
+ * @group Models
+ */
+declare abstract class DotObject {
+}
+
+/**
+ * Base class for Graph objects.
+ * @group Models
+ */
+export declare abstract class GraphBase<T extends AttributeKey> extends AttributesBase<T> implements GraphBaseModel<T> {
+    #private;
+    readonly id?: string;
+    comment?: string;
+    readonly attributes: Readonly<GraphCommonAttributes>;
+    get nodes(): ReadonlyArray<NodeModel>;
+    get edges(): ReadonlyArray<EdgeModel>;
+    get subgraphs(): ReadonlyArray<SubgraphModel>;
+    with(models: Partial<ModelsContext>): void;
+    addNode(node: NodeModel): void;
+    addEdge(edge: EdgeModel): void;
+    addSubgraph(subgraph: SubgraphModel): void;
+    existNode(nodeId: string): boolean;
+    existEdge(edge: EdgeModel): boolean;
+    existSubgraph(subgraph: SubgraphModel): boolean;
+    createSubgraph(id?: string, attributes?: SubgraphAttributesObject): SubgraphModel;
+    createSubgraph(attributes?: SubgraphAttributesObject): SubgraphModel;
+    removeNode(node: NodeModel | string): void;
+    removeEdge(edge: EdgeModel): void;
+    removeSubgraph(subgraph: SubgraphModel): void;
+    createNode(id: string, attributes?: NodeAttributesObject): NodeModel;
+    getSubgraph(id: string): SubgraphModel | undefined;
+    getNode(id: string): NodeModel | undefined;
+    createEdge(targets: EdgeTargetLikeTuple, attributes?: EdgeAttributesObject): EdgeModel;
+    subgraph(id: string, callback?: (subgraph: SubgraphModel) => void): SubgraphModel;
+    subgraph(id: string, attributes: SubgraphAttributesObject, callback?: (subgraph: SubgraphModel) => void): SubgraphModel;
+    subgraph(attributes: SubgraphAttributesObject, callback?: (subgraph: SubgraphModel) => void): SubgraphModel;
+    subgraph(callback?: (subgraph: SubgraphModel) => void): SubgraphModel;
+    node(id: string, callback?: (node: NodeModel) => void): NodeModel;
+    node(id: string, attributes: NodeAttributesObject, callback?: (node: NodeModel) => void): NodeModel;
+    node(attributes: NodeAttributesObject): void;
+    edge(targets: EdgeTargetLikeTuple, callback?: (edge: EdgeModel) => void): EdgeModel;
+    edge(targets: EdgeTargetLikeTuple, attributes: EdgeAttributesObject, callback?: (edge: EdgeModel) => void): EdgeModel;
+    edge(attributes: EdgeAttributesObject): void;
+    graph(attributes: SubgraphAttributesObject): void;
+}
+
+export { }