@ts-graphviz/core 0.0.0-next-20240301111950

package/lib/GraphBase.js

@@ -0,0 +1,152 @@
+import { RootModelsContext, createModelsContext, isNodeRefGroupLike, toNodeRefGroup, toNodeRef } from "@ts-graphviz/common";
+import { AttributeList } from "./AttributeList.js";
+import { AttributesBase } from "./AttributesBase.js";
+class GraphBase extends AttributesBase {
+  /** @hidden */
+  #models = RootModelsContext;
+  id;
+  comment;
+  attributes = Object.freeze({
+    graph: new AttributeList("Graph"),
+    edge: new AttributeList("Edge"),
+    node: new 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 = 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) => isNodeRefGroupLike(t) ? toNodeRefGroup(t) : 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);
+  }
+}
+export {
+  GraphBase
+};

package/lib/Node.cjs

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const AttributesGroup = require("./AttributesGroup.cjs");
+const DotObject = require("./DotObject.cjs");
+class Node extends DotObject.DotObject {
+  constructor(id, attributes) {
+    super();
+    this.id = id;
+    this.attributes = new AttributesGroup.AttributesGroup(attributes);
+  }
+  get $$type() {
+    return "Node";
+  }
+  comment;
+  attributes;
+  port(port) {
+    if (typeof port === "string") {
+      return { id: this.id, port };
+    }
+    return { id: this.id, ...port };
+  }
+}
+exports.Node = Node;

package/lib/Node.d.ts

@@ -0,0 +1,64 @@
+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 { AttributesGroupModel } from '@ts-graphviz/common';
+import { AttributesObject } from '@ts-graphviz/common';
+import { ForwardRefNode } from '@ts-graphviz/common';
+import { NodeAttributeKey } from '@ts-graphviz/common';
+import { NodeAttributesObject } from '@ts-graphviz/common';
+import { NodeModel } from '@ts-graphviz/common';
+import { Port } from '@ts-graphviz/common';
+
+/**
+ * Base class for DOT objects with attributes.
+ * @group Models
+ */
+declare abstract class AttributesBase<T extends AttributeKey> extends DotObject_2 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;
+}
+
+/**
+ * A set of attribute values for any object.
+ * @group Models
+ */
+declare class AttributesGroup<T extends AttributeKey = AttributeKey> extends AttributesBase<T> implements AttributesGroupModel<T> {
+    comment?: string;
+}
+
+/**
+ * Base class for DOT objects.
+ * @group Models
+ */
+declare abstract class DotObject {
+}
+
+/**
+ * Base class for DOT objects.
+ * @group Models
+ */
+declare abstract class DotObject_2 {
+}
+
+/**
+ * DOT object class representing a node.
+ * @group Models
+ */
+export declare class Node extends DotObject implements NodeModel {
+    readonly id: string;
+    get $$type(): 'Node';
+    comment?: string;
+    readonly attributes: AttributesGroup<NodeAttributeKey>;
+    constructor(id: string, attributes?: NodeAttributesObject);
+    port(port: string | Partial<Port>): ForwardRefNode;
+}
+
+export { }

package/lib/Node.js

@@ -0,0 +1,23 @@
+import { AttributesGroup } from "./AttributesGroup.js";
+import { DotObject } from "./DotObject.js";
+class Node extends DotObject {
+  constructor(id, attributes) {
+    super();
+    this.id = id;
+    this.attributes = new AttributesGroup(attributes);
+  }
+  get $$type() {
+    return "Node";
+  }
+  comment;
+  attributes;
+  port(port) {
+    if (typeof port === "string") {
+      return { id: this.id, port };
+    }
+    return { id: this.id, ...port };
+  }
+}
+export {
+  Node
+};

package/lib/RootGraph.cjs

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const GraphBase = require("./GraphBase.cjs");
+class RootGraph extends GraphBase.GraphBase {
+  get $$type() {
+    return "Graph";
+  }
+  id;
+  strict;
+  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 !== void 0) {
+      this.apply(attributes);
+    }
+  }
+}
+exports.RootGraph = RootGraph;

package/lib/RootGraph.d.ts

@@ -0,0 +1,99 @@
+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 {
+}
+
+/**
+ * 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
+ */
+export 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/RootGraph.js

@@ -0,0 +1,22 @@
+import { GraphBase } from "./GraphBase.js";
+class RootGraph extends GraphBase {
+  get $$type() {
+    return "Graph";
+  }
+  id;
+  strict;
+  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 !== void 0) {
+      this.apply(attributes);
+    }
+  }
+}
+export {
+  RootGraph
+};

package/lib/Subgraph.cjs

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const GraphBase = require("./GraphBase.cjs");
+class Subgraph extends GraphBase.GraphBase {
+  get $$type() {
+    return "Subgraph";
+  }
+  id;
+  constructor(...args) {
+    super();
+    this.id = args.find((arg) => typeof arg === "string");
+    const attributes = args.find(
+      (arg) => typeof arg === "object" && arg !== null
+    );
+    if (attributes !== void 0) {
+      this.apply(attributes);
+    }
+  }
+  isSubgraphCluster() {
+    if (typeof this.id === "string") {
+      return this.id.startsWith("cluster");
+    }
+    return false;
+  }
+}
+exports.Subgraph = Subgraph;

package/lib/Subgraph.d.ts

@@ -0,0 +1,95 @@
+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 { ClusterSubgraphAttributeKey } 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 { SubgraphAttributeKey } 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
+ */
+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;
+}
+
+/**
+ * DOT object class representing a subgraph.
+ * @group Models
+ */
+export declare class Subgraph extends GraphBase<SubgraphAttributeKey | ClusterSubgraphAttributeKey> implements SubgraphModel {
+    get $$type(): 'Subgraph';
+    readonly id?: string;
+    constructor(id?: string, attributes?: SubgraphAttributesObject);
+    constructor(attributes?: SubgraphAttributesObject);
+    isSubgraphCluster(): boolean;
+}
+
+export { }

package/lib/Subgraph.js

@@ -0,0 +1,26 @@
+import { GraphBase } from "./GraphBase.js";
+class Subgraph extends GraphBase {
+  get $$type() {
+    return "Subgraph";
+  }
+  id;
+  constructor(...args) {
+    super();
+    this.id = args.find((arg) => typeof arg === "string");
+    const attributes = args.find(
+      (arg) => typeof arg === "object" && arg !== null
+    );
+    if (attributes !== void 0) {
+      this.apply(attributes);
+    }
+  }
+  isSubgraphCluster() {
+    if (typeof this.id === "string") {
+      return this.id.startsWith("cluster");
+    }
+    return false;
+  }
+}
+export {
+  Subgraph
+};

package/lib/core.cjs

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const registerDefault = require("./register-default.cjs");
+const AttributeList = require("./AttributeList.cjs");
+const AttributesBase = require("./AttributesBase.cjs");
+const AttributesGroup = require("./AttributesGroup.cjs");
+const Digraph = require("./Digraph.cjs");
+const DotObject = require("./DotObject.cjs");
+const Edge = require("./Edge.cjs");
+const Graph = require("./Graph.cjs");
+const GraphBase = require("./GraphBase.cjs");
+const Node = require("./Node.cjs");
+const RootGraph = require("./RootGraph.cjs");
+const Subgraph = require("./Subgraph.cjs");
+exports.registerDefault = registerDefault.registerDefault;
+exports.AttributeList = AttributeList.AttributeList;
+exports.AttributesBase = AttributesBase.AttributesBase;
+exports.AttributesGroup = AttributesGroup.AttributesGroup;
+exports.Digraph = Digraph.Digraph;
+exports.DotObject = DotObject.DotObject;
+exports.Edge = Edge.Edge;
+exports.Graph = Graph.Graph;
+exports.GraphBase = GraphBase.GraphBase;
+exports.Node = Node.Node;
+exports.RootGraph = RootGraph.RootGraph;
+exports.Subgraph = Subgraph.Subgraph;