@ts-graphviz/core 0.0.0-pr956-20240225073457

package/lib/core.js

@@ -0,0 +1,397 @@
+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;
+import { RootModelsContext, createModelsContext, isNodeRefGroupLike, toNodeRefGroup, toNodeRef, isNodeRefLike } from "@ts-graphviz/common";
+import { fromModel, stringify, parse, toModel } from "@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, 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, 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) => isNodeRefGroupLike(t) ? toNodeRefGroup(t) : 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 && (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";
+  }
+}
+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(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 = 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 = createModelsContext(models);
+  return Object.freeze({
+    ...createModelFactories(false, context),
+    strict: createModelFactories(true, context)
+  });
+}
+function toDot(model, options) {
+  const ast = fromModel(model, options == null ? void 0 : options.convert);
+  return stringify(ast, options == null ? void 0 : options.print);
+}
+function fromDot(dot, options) {
+  const ast = parse(dot, options == null ? void 0 : options.parse);
+  if (Array.isArray(ast) || ast.type === "Attribute" || ast.type === "AttributeList" || ast.type === "Comment" || ast.type === "NodeRef" || ast.type === "NodeRefGroup" || ast.type === "Literal") {
+    throw new Error();
+  }
+  return toModel(ast, options == null ? void 0 : options.convert);
+}
+export {
+  AttributeList,
+  AttributesBase,
+  AttributesGroup,
+  Digraph,
+  DotObject,
+  Edge,
+  Graph,
+  GraphBase,
+  Node,
+  RootGraph,
+  Subgraph,
+  attribute,
+  digraph,
+  fromDot,
+  graph,
+  strict,
+  toDot,
+  withContext
+};

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@ts-graphviz/core",
+  "version": "0.0.0-pr956-20240225073457",
+  "description": "",
+  "type": "module",
+  "main": "lib/core.cjs",
+  "module": "lib/core.js",
+  "types": "lib/core.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ts-graphviz/ts-graphviz.git",
+    "directory": "packages/core"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "author": "Yuki Yamazaki <yuki@kamiazya.tech>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/ts-graphviz/ts-graphviz/issues"
+  },
+  "homepage": "https://github.com/ts-graphviz/ts-graphviz#readme",
+  "sideEffects": true,
+  "dependencies": {
+    "@ts-graphviz/ast": "^0.0.0-pr956-20240225073457",
+    "@ts-graphviz/common": "^0.0.0-pr956-20240225073457"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.3",
+    "vite": "^5.1.3",
+    "vite-plugin-dts": "^3.7.2"
+  },
+  "scripts": {
+    "build": "vite build"
+  }
+}

package/src/attribute.ts

@@ -0,0 +1,18 @@
+import { Attribute } from '@ts-graphviz/common';
+
+/**
+ * @group Attribute
+ *
+ * @deprecated Use {@link Attribute.keys} instead.
+ */
+export type AttributeKeyDict = Attribute.keys;
+
+/**
+ * @group Attribute
+ */
+export const attribute: Attribute.keys = new Proxy(
+  Object.freeze({}) as Attribute.keys,
+  {
+    get: (_, key: string) => key,
+  },
+);

package/src/core.ts

@@ -0,0 +1,5 @@
+export * from './attribute.js';
+export * from './models/index.js';
+export * from './model-factory/index.js';
+export * from './to-dot.js';
+export * from './from-dot.js';

package/src/from-dot.ts

@@ -0,0 +1,73 @@
+import {
+  ConvertToModelOptions,
+  ParseOptions,
+  parse,
+  toModel,
+} from '@ts-graphviz/ast';
+import {
+  EdgeModel,
+  NodeModel,
+  RootGraphModel,
+  SubgraphModel,
+} from '@ts-graphviz/common';
+
+/**
+ * This interface provides options for converting DOT to a model.
+ * @group Convert DOT to Model
+ */
+export interface FromDotOptions<
+  T extends 'Dot' | 'Graph' | 'Node' | 'Edge' | 'Subgraph',
+> {
+  /**
+   * Options for parsing DOT.
+   */
+  parse?: ParseOptions<T>;
+  /**
+   * Options for converting the parsed DOT to a model.
+   */
+  convert?: ConvertToModelOptions;
+}
+
+/**
+ * fromDot is a function that converts a DOT string to a model.
+ *
+ * @group Convert DOT to Model
+ *
+ * @param dot The DOT string to convert.
+ * @param options Options for converting the DOT string to a model.
+ * @returns A model of type {@link RootGraphModel}, {@link NodeModel}, {@link EdgeModel}, or {@link SubgraphModel},
+ * depending on the type specified in the options.
+ */
+export function fromDot(
+  dot: string,
+  options?: FromDotOptions<'Dot' | 'Graph'>,
+): RootGraphModel;
+export function fromDot(
+  dot: string,
+  options?: FromDotOptions<'Node'>,
+): NodeModel;
+export function fromDot(
+  dot: string,
+  options?: FromDotOptions<'Edge'>,
+): EdgeModel;
+export function fromDot(
+  dot: string,
+  options?: FromDotOptions<'Subgraph'>,
+): SubgraphModel;
+export function fromDot<
+  T extends 'Dot' | 'Graph' | 'Node' | 'Edge' | 'Subgraph',
+>(dot: string, options?: FromDotOptions<T>) {
+  const ast = parse(dot, options?.parse);
+  if (
+    Array.isArray(ast) ||
+    ast.type === 'Attribute' ||
+    ast.type === 'AttributeList' ||
+    ast.type === 'Comment' ||
+    ast.type === 'NodeRef' ||
+    ast.type === 'NodeRefGroup' ||
+    ast.type === 'Literal'
+  ) {
+    throw new Error();
+  }
+  return toModel(ast, options?.convert);
+}

package/src/model-factory/index.ts

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './model-factory.js';

package/src/model-factory/model-factory-builder.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, test, vi } from 'vitest';
+
+import { RootModelsContext } from '@ts-graphviz/common';
+import { attribute as _ } from '../attribute.js';
+import '../models/registerModelContext.js';
+import { ModelFactoryBuilder } from './model-factory-builder.js';
+
+describe.each([
+  { directed: true, strict: true },
+  { directed: false, strict: true },
+  { directed: false, strict: false },
+  { directed: true, strict: false },
+])('strict: %s, directed: %s', ({ strict, directed }) => {
+  const factory = ModelFactoryBuilder.call(RootModelsContext, directed, strict);
+
+  test('no arguments', () => {
+    const g = factory();
+    expect(g.directed).toStrictEqual(directed);
+    expect(g.strict).toStrictEqual(strict);
+  });
+
+  test('first argument is id', () => {
+    const g = factory('foo');
+    expect(g.id).toStrictEqual('foo');
+
+    expect(g.directed).toStrictEqual(directed);
+    expect(g.strict).toStrictEqual(strict);
+  });
+
+  test('first argument is callback', () => {
+    const callback = vi.fn();
+    const g = factory(callback);
+    expect(g.id).toBeUndefined();
+    expect(callback).toHaveBeenCalledWith(g);
+
+    expect(g.directed).toStrictEqual(directed);
+    expect(g.strict).toStrictEqual(strict);
+  });
+
+  test('first argument is attribute object', () => {
+    const g = factory({ [_.label]: 'Test label' });
+    expect(g.id).toBeUndefined();
+    expect(g.values).toStrictEqual([[_.label, 'Test label']]);
+
+    expect(g.directed).toStrictEqual(directed);
+    expect(g.strict).toStrictEqual(strict);
+  });
+
+  test('first argument is attribute object, seccond argument is callback', () => {
+    const callback = vi.fn();
+    const g = factory({ [_.label]: 'Test label' }, callback);
+    expect(g.id).toBeUndefined();
+    expect(g.values).toStrictEqual([[_.label, 'Test label']]);
+    expect(callback).toHaveBeenCalledWith(g);
+
+    expect(g.directed).toStrictEqual(directed);
+    expect(g.strict).toStrictEqual(strict);
+  });
+
+  test('first argument is id, seccond argument is attribute object', () => {
+    const g = factory('foo', { [_.label]: 'Test label' });
+    expect(g.id).toStrictEqual('foo');
+    expect(g.values).toStrictEqual([[_.label, 'Test label']]);
+
+    expect(g.directed).toStrictEqual(directed);
+    expect(g.strict).toStrictEqual(strict);
+  });
+
+  test('first argument is id, seccond argument is attribute object, third arguments is callback', () => {
+    const callback = vi.fn();
+    const g = factory('foo', { [_.label]: 'Test label' }, callback);
+    expect(g.id).toStrictEqual('foo');
+    expect(g.values).toStrictEqual([[_.label, 'Test label']]);
+    expect(callback).toHaveBeenCalledWith(g);
+
+    expect(g.directed).toStrictEqual(directed);
+    expect(g.strict).toStrictEqual(strict);
+  });
+});

package/src/model-factory/model-factory-builder.ts

@@ -0,0 +1,55 @@
+import {
+  GraphAttributesObject,
+  ModelsContext,
+  RootGraphModel,
+  RootModelsContext,
+} from '@ts-graphviz/common';
+import { ModelFactory } from './types.js';
+
+/**
+ * ModelFactoryBuilder is a function that takes two parameters, directed and strictMode, and returns a ModelFactory.
+ *
+ * @param directed A boolean value indicating whether the graph should be directed or not.
+ * @param strictMode A boolean value indicating whether the graph should be in strict mode or not.
+ * @returns A ModelFactory that takes an array of unknowns as parameters and returns a RootGraphModel.
+ * @hidden
+ */
+export function ModelFactoryBuilder(
+  this: ModelsContext,
+  directed: boolean,
+  strictMode: boolean,
+): ModelFactory {
+  return (...args: unknown[]) => {
+    const G = directed ? this.Digraph : this.Graph;
+    const id = args.find((arg): arg is string => typeof arg === 'string');
+    const attributes = args.find(
+      (arg): arg is GraphAttributesObject => typeof arg === 'object',
+    );
+    const callback = args.find(
+      (arg): arg is (g: RootGraphModel) => void => typeof arg === 'function',
+    );
+    const g = new G(id, strictMode, attributes);
+    g.with(this);
+    if (typeof callback === 'function') {
+      callback(g);
+    }
+    return g;
+  };
+}
+
+/**
+ * createModelFactories is a function that takes a boolean value, strict, and an optional ModelsContext parameter, context, and returns an object containing two ModelFactories.
+ *
+ * @param strict A boolean value indicating whether the graph should be in strict mode or not.
+ * @param context An optional ModelsContext parameter.
+ * @returns An object containing two ModelFactories, one for directed graphs and one for undirected graphs.
+ */
+export function createModelFactories(
+  strict: boolean,
+  context: ModelsContext = RootModelsContext,
+) {
+  return Object.freeze({
+    digraph: ModelFactoryBuilder.call(context, true, strict),
+    graph: ModelFactoryBuilder.call(context, false, strict),
+  });
+}