@ts-graphviz/core 0.0.0-pr956-20240225073457

package/CHANGELOG.md

@@ -0,0 +1,13 @@
+# @ts-graphviz/core
+
+## 0.0.0-pr956-20240225073457
+
+### Major Changes
+
+- [`6b2f0e8`](https://github.com/ts-graphviz/ts-graphviz/commit/6b2f0e8349605b4fe0dd950147ba3a8285b24b24) Thanks [@kamiazya](https://github.com/kamiazya)! - Release v2.0.0
+
+### Patch Changes
+
+- Updated dependencies [[`6b2f0e8`](https://github.com/ts-graphviz/ts-graphviz/commit/6b2f0e8349605b4fe0dd950147ba3a8285b24b24)]:
+  - @ts-graphviz/common@0.0.0-pr956-20240225073457
+  - @ts-graphviz/ast@0.0.0-pr956-20240225073457

package/LICENSE

@@ -0,0 +1,22 @@
+
+The MIT License (MIT)
+
+Copyright (c) 2019-2024 Yuki Yamazaki
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,47 @@
+# @ts-graphviz/core
+
+This package contains the core implementation of models and functions provided to users for the ts-graphviz library.
+
+It is part of the ts-graphviz library, which is split into modular packages to improve maintainability, flexibility, and ease of use.
+
+## Features
+
+- Graph, Node, and Edge model implementations
+- High-level APIs for creating and manipulating DOT language elements
+- Extensible design for custom implementations
+
+## Usage
+
+Import the necessary classes and functions from the @ts-graphviz/core package:
+
+```ts
+import { Graph, Node, Edge } from '@ts-graphviz/core';
+```
+
+Use the imported items in your project to create and manipulate DOT language elements:
+
+```ts
+const graph = new Graph('G');
+const nodeA = new Node('A', { label: 'Node A' });
+const nodeB = new Node('B', { label: 'Node B' });
+const edge = new Edge([nodeA, nodeB], { label: 'A -> B' });
+
+graph.addNode(nodeA);
+graph.addNode(nodeB);
+graph.addEdge(edge);
+
+console.log(graph.toDot());
+```
+
+For more examples and usage details, please refer to the ts-graphviz documentation.
+
+
+## Contributing
+
+Contributions to the ts-graphviz project are welcome.
+
+Please refer to the main ts-graphviz repository for guidelines on how to contribute.
+
+## License
+
+This package is released under the MIT License.

package/lib/core.cjs

@@ -0,0 +1,397 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var _attrs, _models, _objects;
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const common = require("@ts-graphviz/common");
+const ast = require("@ts-graphviz/ast");
+const attribute = new Proxy(
+  Object.freeze({}),
+  {
+    get: (_, key) => key
+  }
+);
+class DotObject {
+}
+class AttributesBase extends DotObject {
+  constructor(attributes) {
+    super();
+    /** @hidden */
+    __privateAdd(this, _attrs, /* @__PURE__ */ new Map());
+    if (attributes !== void 0) {
+      this.apply(attributes);
+    }
+  }
+  get values() {
+    return Array.from(__privateGet(this, _attrs).entries());
+  }
+  get size() {
+    return __privateGet(this, _attrs).size;
+  }
+  get(key) {
+    return __privateGet(this, _attrs).get(key);
+  }
+  set(key, value) {
+    if (value !== null && value !== void 0) {
+      __privateGet(this, _attrs).set(key, value);
+    }
+  }
+  delete(key) {
+    __privateGet(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() {
+    __privateGet(this, _attrs).clear();
+  }
+}
+_attrs = new WeakMap();
+class AttributeList extends AttributesBase {
+  constructor($$kind, attributes) {
+    super(attributes);
+    __publicField(this, "comment");
+    this.$$kind = $$kind;
+  }
+  get $$type() {
+    return "AttributeList";
+  }
+}
+class GraphBase extends AttributesBase {
+  constructor() {
+    super(...arguments);
+    /** @hidden */
+    __privateAdd(this, _models, common.RootModelsContext);
+    __publicField(this, "id");
+    __publicField(this, "comment");
+    __publicField(this, "attributes", Object.freeze({
+      graph: new AttributeList("Graph"),
+      edge: new AttributeList("Edge"),
+      node: new AttributeList("Node")
+    }));
+    /** @hidden */
+    __privateAdd(this, _objects, {
+      nodes: /* @__PURE__ */ new Map(),
+      edges: /* @__PURE__ */ new Set(),
+      subgraphs: /* @__PURE__ */ new Set()
+    });
+  }
+  get nodes() {
+    return Array.from(__privateGet(this, _objects).nodes.values());
+  }
+  get edges() {
+    return Array.from(__privateGet(this, _objects).edges.values());
+  }
+  get subgraphs() {
+    return Array.from(__privateGet(this, _objects).subgraphs.values());
+  }
+  with(models) {
+    __privateSet(this, _models, common.createModelsContext(models));
+  }
+  addNode(node) {
+    __privateGet(this, _objects).nodes.set(node.id, node);
+  }
+  addEdge(edge) {
+    __privateGet(this, _objects).edges.add(edge);
+  }
+  addSubgraph(subgraph) {
+    __privateGet(this, _objects).subgraphs.add(subgraph);
+  }
+  existNode(nodeId) {
+    return __privateGet(this, _objects).nodes.has(nodeId);
+  }
+  existEdge(edge) {
+    return __privateGet(this, _objects).edges.has(edge);
+  }
+  existSubgraph(subgraph) {
+    return __privateGet(this, _objects).subgraphs.has(subgraph);
+  }
+  createSubgraph(...args) {
+    const subgraph = new (__privateGet(this, _models)).Subgraph(...args);
+    subgraph.with(__privateGet(this, _models));
+    this.addSubgraph(subgraph);
+    return subgraph;
+  }
+  removeNode(node) {
+    __privateGet(this, _objects).nodes.delete(typeof node === "string" ? node : node.id);
+  }
+  removeEdge(edge) {
+    __privateGet(this, _objects).edges.delete(edge);
+  }
+  removeSubgraph(subgraph) {
+    __privateGet(this, _objects).subgraphs.delete(subgraph);
+  }
+  createNode(id, attributes) {
+    const node = new (__privateGet(this, _models)).Node(id, attributes);
+    this.addNode(node);
+    return node;
+  }
+  getSubgraph(id) {
+    return Array.from(__privateGet(this, _objects).subgraphs.values()).find(
+      (subgraph) => subgraph.id === id
+    );
+  }
+  getNode(id) {
+    return __privateGet(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 (__privateGet(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);
+  }
+}
+_models = new WeakMap();
+_objects = new WeakMap();
+class RootGraph extends GraphBase {
+  constructor(...args) {
+    super();
+    __publicField(this, "id");
+    __publicField(this, "strict");
+    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);
+    }
+  }
+  get $$type() {
+    return "Graph";
+  }
+}
+class Digraph extends RootGraph {
+  get directed() {
+    return true;
+  }
+}
+class AttributesGroup extends AttributesBase {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "comment");
+  }
+}
+class Edge extends DotObject {
+  constructor(targets, attributes) {
+    super();
+    __publicField(this, "comment");
+    __publicField(this, "attributes");
+    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(attributes);
+  }
+  get $$type() {
+    return "Edge";
+  }
+}
+class Graph extends RootGraph {
+  get directed() {
+    return false;
+  }
+}
+class Node extends DotObject {
+  constructor(id, attributes) {
+    super();
+    __publicField(this, "comment");
+    __publicField(this, "attributes");
+    this.id = id;
+    this.attributes = new AttributesGroup(attributes);
+  }
+  get $$type() {
+    return "Node";
+  }
+  port(port) {
+    if (typeof port === "string") {
+      return { id: this.id, port };
+    }
+    return { id: this.id, ...port };
+  }
+}
+class Subgraph extends GraphBase {
+  constructor(...args) {
+    super();
+    __publicField(this, "id");
+    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);
+    }
+  }
+  get $$type() {
+    return "Subgraph";
+  }
+  isSubgraphCluster() {
+    if (typeof this.id === "string") {
+      return this.id.startsWith("cluster");
+    }
+    return false;
+  }
+}
+Object.assign(common.RootModelsContext, {
+  Graph,
+  Digraph,
+  Subgraph,
+  Node,
+  Edge
+});
+function ModelFactoryBuilder(directed, strictMode) {
+  return (...args) => {
+    const G = directed ? this.Digraph : this.Graph;
+    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 G(id, strictMode, attributes);
+    g.with(this);
+    if (typeof callback === "function") {
+      callback(g);
+    }
+    return g;
+  };
+}
+function createModelFactories(strict2, context = common.RootModelsContext) {
+  return Object.freeze({
+    digraph: ModelFactoryBuilder.call(context, true, strict2),
+    graph: ModelFactoryBuilder.call(context, false, strict2)
+  });
+}
+const noStrict = createModelFactories(false);
+const digraph = noStrict.digraph;
+const graph = noStrict.graph;
+const strict = createModelFactories(true);
+function withContext(models) {
+  const context = common.createModelsContext(models);
+  return Object.freeze({
+    ...createModelFactories(false, context),
+    strict: createModelFactories(true, context)
+  });
+}
+function toDot(model, options) {
+  const ast$1 = ast.fromModel(model, options == null ? void 0 : options.convert);
+  return ast.stringify(ast$1, options == null ? void 0 : options.print);
+}
+function fromDot(dot, options) {
+  const ast$1 = ast.parse(dot, options == null ? void 0 : options.parse);
+  if (Array.isArray(ast$1) || ast$1.type === "Attribute" || ast$1.type === "AttributeList" || ast$1.type === "Comment" || ast$1.type === "NodeRef" || ast$1.type === "NodeRefGroup" || ast$1.type === "Literal") {
+    throw new Error();
+  }
+  return ast.toModel(ast$1, options == null ? void 0 : options.convert);
+}
+exports.AttributeList = AttributeList;
+exports.AttributesBase = AttributesBase;
+exports.AttributesGroup = AttributesGroup;
+exports.Digraph = Digraph;
+exports.DotObject = DotObject;
+exports.Edge = Edge;
+exports.Graph = Graph;
+exports.GraphBase = GraphBase;
+exports.Node = Node;
+exports.RootGraph = RootGraph;
+exports.Subgraph = Subgraph;
+exports.attribute = attribute;
+exports.digraph = digraph;
+exports.fromDot = fromDot;
+exports.graph = graph;
+exports.strict = strict;
+exports.toDot = toDot;
+exports.withContext = withContext;