@ts-graphviz/core 0.0.0-pr956-20240225073457

package/src/models/RootGraph.spec.ts

@@ -0,0 +1,69 @@
+import { beforeEach, describe, expect, it, test } from 'vitest';
+import './registerModelContext.js';
+
+import { attribute as _ } from '../attribute.js';
+import { DotObject } from './DotObject.js';
+import { GraphBase } from './GraphBase.js';
+import { RootGraph } from './RootGraph.js';
+
+class TestRootGraph extends RootGraph {
+  public directed = true;
+}
+
+let g: RootGraph;
+beforeEach(() => {
+  g = new TestRootGraph();
+});
+
+describe('Constructor', () => {
+  test('no args', () => {
+    g = new TestRootGraph();
+    expect(g.id).toBeUndefined();
+    expect(g.values).toStrictEqual([]);
+    expect(g.strict).toStrictEqual(false);
+  });
+
+  test('first argument is id', () => {
+    g = new TestRootGraph('foo');
+    expect(g.id).toStrictEqual('foo');
+    expect(g.values).toStrictEqual([]);
+    expect(g.strict).toStrictEqual(false);
+  });
+
+  test('first argument is id, seccond argument is strict, third argument is attribute object', () => {
+    g = new TestRootGraph('foo', true, { [_.label]: 'Test label' });
+    expect(g.id).toStrictEqual('foo');
+    expect(g.values).toStrictEqual([[_.label, 'Test label']]);
+    expect(g.strict).toStrictEqual(true);
+  });
+
+  test('first argument is attribute object', () => {
+    g = new TestRootGraph({ [_.label]: 'Test label' });
+    expect(g.id).toBeUndefined();
+    expect(g.values).toStrictEqual([[_.label, 'Test label']]);
+    expect(g.strict).toStrictEqual(false);
+  });
+
+  test('first argument is strict', () => {
+    g = new TestRootGraph(true);
+    expect(g.id).toBeUndefined();
+    expect(g.values).toStrictEqual([]);
+    expect(g.strict).toStrictEqual(true);
+  });
+
+  test('first argument is strict, seccond is attribute object', () => {
+    g = new TestRootGraph(true, { [_.label]: 'Test label' });
+    expect(g.id).toBeUndefined();
+    expect(g.values).toStrictEqual([[_.label, 'Test label']]);
+    expect(g.strict).toStrictEqual(true);
+  });
+});
+
+it('should be instance of GraphBase/DotObject', () => {
+  expect(g).toBeInstanceOf(GraphBase);
+  expect(g).toBeInstanceOf(DotObject);
+});
+
+test('$$type propaty should be "Graph"', () => {
+  expect(g.$$type).toStrictEqual('Graph');
+});

package/src/models/RootGraph.ts

@@ -0,0 +1,48 @@
+import {
+  GraphAttributeKey,
+  GraphAttributesObject,
+  RootGraphModel,
+} from '@ts-graphviz/common';
+import { GraphBase } from './GraphBase.js';
+
+/**
+ * Base class representing a root graph(digraph, graph).
+ * @group Models
+ */
+export abstract class RootGraph
+  extends GraphBase<GraphAttributeKey>
+  implements RootGraphModel
+{
+  public get $$type(): 'Graph' {
+    return 'Graph';
+  }
+  public readonly id?: string;
+  public abstract readonly directed: boolean;
+  public strict: boolean;
+
+  constructor(id?: string, attributes?: GraphAttributesObject);
+
+  constructor(
+    id?: string,
+    strict?: boolean,
+    attributes?: GraphAttributesObject,
+  );
+
+  constructor(strict?: boolean, attributes?: GraphAttributesObject);
+
+  constructor(attributes?: GraphAttributesObject);
+
+  constructor(...args: unknown[]) {
+    super();
+    this.id = args.find((arg): arg is string => typeof arg === 'string');
+    this.strict =
+      args.find((arg): arg is boolean => typeof arg === 'boolean') ?? false;
+    const attributes = args.find(
+      (arg): arg is GraphAttributesObject =>
+        typeof arg === 'object' && arg !== null,
+    );
+    if (attributes !== undefined) {
+      this.apply(attributes);
+    }
+  }
+}

package/src/models/Subgraph.spec.ts

@@ -0,0 +1,196 @@
+import { beforeEach, describe, expect, it, test } from 'vitest';
+import './registerModelContext.js';
+
+import { EdgeTargetTuple, SubgraphModel } from '@ts-graphviz/common';
+import { attribute as _ } from '../attribute.js';
+import { AttributesBase } from './AttributesBase.js';
+import { DotObject } from './DotObject.js';
+import { GraphBase } from './GraphBase.js';
+import { Node } from './Node.js';
+import { Subgraph } from './Subgraph.js';
+
+describe('class Subgraph', () => {
+  let subgraph: SubgraphModel;
+
+  beforeEach(() => {
+    subgraph = new Subgraph();
+  });
+
+  it('should be instance of Subgraph/Cluster/AttributesBase/DotObject', () => {
+    expect(subgraph).toBeInstanceOf(Subgraph);
+    expect(subgraph).toBeInstanceOf(GraphBase);
+    expect(subgraph).toBeInstanceOf(AttributesBase);
+    expect(subgraph).toBeInstanceOf(DotObject);
+  });
+
+  describe('Constructor', () => {
+    test('first argument is id, and second attributes object', () => {
+      subgraph = new Subgraph('test', {
+        [_.K]: 1,
+      });
+      expect(subgraph.id).toBe('test');
+      expect(subgraph.get(_.K)).toBe(1);
+    });
+    test('first argument is attributes object', () => {
+      subgraph = new Subgraph({
+        [_.K]: 1,
+      });
+      expect(subgraph.get(_.K)).toBe(1);
+    });
+  });
+
+  describe('Declaratively set the attributes of the objects in the cluster', () => {
+    test('node', () => {
+      subgraph.node({
+        label: 'test label',
+      });
+      expect(subgraph.attributes.node.get(_.label)).toBe('test label');
+    });
+
+    test('edge', () => {
+      subgraph.edge({
+        label: 'test label',
+      });
+      expect(subgraph.attributes.edge.get(_.label)).toBe('test label');
+    });
+
+    test('graph', () => {
+      subgraph.graph({
+        label: 'test label',
+      });
+      expect(subgraph.attributes.graph.get(_.label)).toBe('test label');
+    });
+  });
+
+  test('set attributes', () => {
+    subgraph.set(_.rank, 'same');
+    expect(subgraph.get(_.rank)).toBe('same');
+  });
+
+  describe('set attributes by apply', () => {
+    test('with attributes object', () => {
+      subgraph.apply({
+        [_.rank]: 'same',
+      });
+      expect(subgraph.get(_.rank)).toBe('same');
+    });
+
+    test('with entities', () => {
+      subgraph.apply([[_.rank, 'same']]);
+      expect(subgraph.get(_.rank)).toBe('same');
+    });
+  });
+
+  it('should be subgraph, when subgraph id is "test"', () => {
+    expect(subgraph.isSubgraphCluster()).toBe(false);
+  });
+
+  test('create node with attributes', () => {
+    const node = subgraph.createNode('n', {
+      [_.label]: 'Label',
+    });
+    expect(node.id).toBe('n');
+    expect(node.attributes.size).toBe(1);
+  });
+
+  test('create edge with attributes', () => {
+    const nodes = [...Array(2)].map((_v, i) =>
+      subgraph.createNode(`node${i + 1}`),
+    ) as EdgeTargetTuple;
+    const edge = subgraph.createEdge(nodes, {
+      [_.label]: 'Label',
+    });
+    expect(edge.attributes.size).toBe(1);
+  });
+
+  test('create edge by node group', () => {
+    const [node1, node2, node3, node4] = Array(4)
+      .fill(true)
+      .map((_v, i) => subgraph.createNode(`node${i + 1}`));
+    const edge = subgraph.createEdge([node1, [node2, node3], node4]);
+    expect(edge.targets.length).toBe(3);
+  });
+
+  test('create subgraph with attributes', () => {
+    subgraph = subgraph.createSubgraph('test', {
+      [_.label]: 'Label',
+    });
+    expect(subgraph.id).toBe('test');
+    expect(subgraph.size).toBe(1);
+
+    subgraph = subgraph.createSubgraph({
+      [_.label]: 'Label',
+    });
+    expect(subgraph.size).toBe(1);
+  });
+
+  test.each([
+    ['cluster', true],
+    ['cluster_hoge', true],
+    ['hoge_cluster', false],
+    ['example', false],
+  ])(
+    'if cluster named "%s", isSubgraphCluster should be %p',
+    (id, expected) => {
+      subgraph = new Subgraph(id);
+      expect(subgraph.isSubgraphCluster()).toBe(expected);
+    },
+  );
+
+  describe('addXxx existXxx removeXxx APIs', () => {
+    it('Node operation methods works', () => {
+      const id = 'node';
+      expect(subgraph.existNode(id)).toBe(false);
+      const node = new Node(id);
+      subgraph.addNode(node);
+      expect(subgraph.existNode(id)).toBe(true);
+      subgraph.removeNode(node);
+      expect(subgraph.existNode(id)).toBe(false);
+      subgraph.addNode(node);
+      expect(subgraph.existNode(id)).toBe(true);
+      subgraph.removeNode(node.id);
+      expect(subgraph.existNode(id)).toBe(false);
+    });
+
+    it('Edge operation methods works', () => {
+      const nodes = [...Array(2)].map((_v, i) =>
+        subgraph.createNode(`node${i + 1}`),
+      ) as EdgeTargetTuple;
+      const edge = subgraph.createEdge(nodes);
+      expect(subgraph.existEdge(edge)).toBe(true);
+      subgraph.removeEdge(edge);
+      expect(subgraph.existEdge(edge)).toBe(false);
+    });
+
+    it('Subgraph operation methods works', () => {
+      const sub = subgraph.createSubgraph('sub');
+      expect(subgraph.existSubgraph(sub)).toBe(true);
+      subgraph.removeSubgraph(sub);
+      expect(subgraph.existSubgraph(sub)).toBe(false);
+      subgraph.addSubgraph(sub);
+      expect(subgraph.existSubgraph(sub)).toBe(true);
+      subgraph.removeSubgraph(sub);
+      expect(subgraph.existSubgraph(sub)).toBe(false);
+    });
+
+    it('should be undefined, when id not set', () => {
+      const sub = subgraph.createSubgraph();
+      expect(sub.id).toBeUndefined();
+      expect(sub.isSubgraphCluster()).toBe(false);
+    });
+
+    it('throws an error when the EdgeTarget element is missing', () => {
+      const n = subgraph.node('n');
+      expect(() =>
+        subgraph.edge([] as unknown as EdgeTargetTuple),
+      ).toThrowErrorMatchingInlineSnapshot(
+        `[Error: The element of Edge target is missing or not satisfied as Edge target.]`,
+      );
+      expect(() =>
+        subgraph.edge([n] as unknown as EdgeTargetTuple),
+      ).toThrowErrorMatchingInlineSnapshot(
+        `[Error: The element of Edge target is missing or not satisfied as Edge target.]`,
+      );
+    });
+  });
+});

package/src/models/Subgraph.ts

@@ -0,0 +1,44 @@
+import {
+  ClusterSubgraphAttributeKey,
+  SubgraphAttributeKey,
+  SubgraphAttributesObject,
+  SubgraphModel,
+} from '@ts-graphviz/common';
+import { GraphBase } from './GraphBase.js';
+
+/**
+ * DOT object class representing a subgraph.
+ * @group Models
+ */
+export class Subgraph
+  extends GraphBase<SubgraphAttributeKey | ClusterSubgraphAttributeKey>
+  implements SubgraphModel
+{
+  public get $$type(): 'Subgraph' {
+    return 'Subgraph';
+  }
+  public readonly id?: string;
+
+  constructor(id?: string, attributes?: SubgraphAttributesObject);
+
+  constructor(attributes?: SubgraphAttributesObject);
+
+  constructor(...args: unknown[]) {
+    super();
+    this.id = args.find((arg): arg is string => typeof arg === 'string');
+    const attributes = args.find(
+      (arg): arg is SubgraphAttributesObject =>
+        typeof arg === 'object' && arg !== null,
+    );
+    if (attributes !== undefined) {
+      this.apply(attributes);
+    }
+  }
+
+  public isSubgraphCluster(): boolean {
+    if (typeof this.id === 'string') {
+      return this.id.startsWith('cluster');
+    }
+    return false;
+  }
+}

package/src/models/index.ts

@@ -0,0 +1,15 @@
+import './registerModelContext.js';
+
+export * from './DotObject.js';
+export * from './AttributesBase.js';
+export * from './AttributeList.js';
+export * from './AttributesBase.js';
+export * from './AttributesGroup.js';
+export * from './Digraph.js';
+export * from './DotObject.js';
+export * from './Edge.js';
+export * from './Graph.js';
+export * from './GraphBase.js';
+export * from './Node.js';
+export * from './RootGraph.js';
+export * from './Subgraph.js';

package/src/models/registerModelContext.ts

@@ -0,0 +1,14 @@
+import { RootModelsContext } from '@ts-graphviz/common';
+import { Digraph } from './Digraph.js';
+import { Edge } from './Edge.js';
+import { Graph } from './Graph.js';
+import { Node } from './Node.js';
+import { Subgraph } from './Subgraph.js';
+
+Object.assign(RootModelsContext, {
+  Graph,
+  Digraph,
+  Subgraph,
+  Node,
+  Edge,
+});

package/src/to-dot.ts

@@ -0,0 +1,36 @@
+import {
+  ConvertFromModelOptions,
+  PrintOptions,
+  fromModel,
+  stringify,
+} from '@ts-graphviz/ast';
+import { DotObjectModel } from '@ts-graphviz/common';
+
+/**
+ * This interface provides options for converting a model to DOT.
+ * @group Convert Model to DOT
+ */
+export interface ToDotOptions {
+  /**
+   * Options for converting the model to DOT.
+   */
+  convert?: ConvertFromModelOptions;
+  /**
+   * Options for printing DOT.
+   */
+  print?: PrintOptions;
+}
+
+/**
+ * Convert Model to DOT string.
+ *
+ * @group Convert Model to DOT
+ *
+ * @param model Dot Object Model, like {@link Digraph}, {@link Graph}, {@link Subgraph}, {@link Node}, and {@link Edge}
+ * @param options Optional options for the conversion.
+ * @returns DOT string
+ */
+export function toDot(model: DotObjectModel, options?: ToDotOptions): string {
+  const ast = fromModel(model, options?.convert);
+  return stringify(ast, options?.print);
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "lib"
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["**/*.test.ts", "**/*.spec.ts"]
+}

package/typedoc.json

@@ -0,0 +1,4 @@
+{
+  "extends": ["../../typedoc.base.json"],
+  "entryPoints": ["src/index.ts"]
+}

package/vite.config.ts

@@ -0,0 +1,22 @@
+import dts from 'vite-plugin-dts';
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  build: {
+    outDir: './lib',
+    minify: false,
+    lib: {
+      entry: './src/core.ts',
+      formats: ['es', 'cjs'],
+    },
+    rollupOptions: {
+      external: ['@ts-graphviz/common', '@ts-graphviz/ast'],
+    },
+  },
+  plugins: [
+    dts({
+      outDir: './lib',
+      rollupTypes: true,
+    }),
+  ],
+});