@ts-graphviz/core 0.0.0-pr956-20240225073457 → 0.0.0-pr956-20240225091623

package/src/models/AttributesBase.ts

@@ -1,62 +0,0 @@
-import {
-  Attribute,
-  AttributeKey,
-  Attributes,
-  AttributesEntities,
-  AttributesObject,
-} from '@ts-graphviz/common';
-import { DotObject } from './DotObject.js';
-
-/**
- * Base class for DOT objects with attributes.
- * @group Models
- */
-export abstract class AttributesBase<T extends AttributeKey>
-  extends DotObject
-  implements Attributes<T>
-{
-  /** @hidden */
-  #attrs: Map<T, Attribute<T>> = new Map();
-
-  constructor(attributes?: AttributesObject<T>) {
-    super();
-    if (attributes !== undefined) {
-      this.apply(attributes);
-    }
-  }
-
-  get values(): ReadonlyArray<[T, Attribute<T>]> {
-    return Array.from(this.#attrs.entries());
-  }
-
-  get size(): number {
-    return this.#attrs.size;
-  }
-
-  public get<K extends T>(key: K): Attribute<K> | undefined {
-    return this.#attrs.get(key) as Attribute<K> | undefined;
-  }
-
-  public set<K extends T>(key: K, value: Attribute<K>): void {
-    if (value !== null && value !== undefined) {
-      this.#attrs.set(key, value);
-    }
-  }
-
-  public delete(key: T): void {
-    this.#attrs.delete(key);
-  }
-
-  public apply(attributes: AttributesObject<T> | AttributesEntities<T>): void {
-    const entries = Array.isArray(attributes)
-      ? attributes
-      : Object.entries(attributes);
-    for (const [key, value] of entries) {
-      this.set(key, value);
-    }
-  }
-
-  public clear(): void {
-    this.#attrs.clear();
-  }
-}

package/src/models/AttributesGroup.spec.ts

@@ -1,18 +0,0 @@
-import { beforeEach, describe, expect, test } from 'vitest';
-import { AttributesGroup } from './AttributesGroup.js';
-
-let attrs: AttributesGroup;
-beforeEach(() => {
-  attrs = new AttributesGroup();
-});
-
-describe('comment', () => {
-  test('default value to be undefined', () => {
-    expect(attrs.comment).toBeUndefined();
-  });
-
-  test('comment can be set', () => {
-    attrs.comment = 'test';
-    expect(attrs.comment).toStrictEqual('test');
-  });
-});

package/src/models/AttributesGroup.ts

@@ -1,13 +0,0 @@
-import { AttributeKey, AttributesGroupModel } from '@ts-graphviz/common';
-import { AttributesBase } from './AttributesBase.js';
-
-/**
- * A set of attribute values for any object.
- * @group Models
- */
-export class AttributesGroup<T extends AttributeKey = AttributeKey>
-  extends AttributesBase<T>
-  implements AttributesGroupModel<T>
-{
-  public comment?: string;
-}

package/src/models/Digraph.spec.ts

@@ -1,17 +0,0 @@
-import { expect, it, test } from 'vitest';
-import { Digraph } from './Digraph.js';
-import { DotObject } from './DotObject.js';
-import { GraphBase } from './GraphBase.js';
-import './registerModelContext.js';
-
-const g = new Digraph();
-
-test('directed propaty should be true', () => {
-  expect(g.directed).toStrictEqual(true);
-});
-
-it('should be instance of Digraph/GraphBase/DotObject', () => {
-  expect(g).toBeInstanceOf(Digraph);
-  expect(g).toBeInstanceOf(GraphBase);
-  expect(g).toBeInstanceOf(DotObject);
-});

package/src/models/Digraph.ts

@@ -1,11 +0,0 @@
-import { RootGraph } from './RootGraph.js';
-
-/**
- * DOT object class representing a digraph.
- * @group Models
- */
-export class Digraph extends RootGraph {
-  public get directed(): boolean {
-    return true;
-  }
-}

package/src/models/DotObject.ts

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

package/src/models/Edge.spec.ts

@@ -1,48 +0,0 @@
-import { beforeEach, describe, expect, it, test } from 'vitest';
-
-import './registerModelContext.js';
-
-import { EdgeTargetTuple } from '@ts-graphviz/common';
-import { attribute as _ } from '../attribute.js';
-import { DotObject } from './DotObject.js';
-import { Edge } from './Edge.js';
-import { Node } from './Node.js';
-
-let edge: Edge;
-
-const targets = [...Array(2)].map(
-  (_, i) => new Node(`node${i + 1}`),
-) as unknown as EdgeTargetTuple;
-
-beforeEach(() => {
-  edge = new Edge(targets);
-});
-
-it('should be instance of Edge/DotObject', () => {
-  expect(edge).toBeInstanceOf(Edge);
-  expect(edge).toBeInstanceOf(DotObject);
-});
-
-describe('Constructor', () => {
-  test('first argument is targets, and second attributes object', () => {
-    edge = new Edge(targets, {
-      [_.label]: 'Label',
-    });
-    expect(edge.attributes.size).toBe(1);
-    expect(edge.attributes.get(_.label)).toBe('Label');
-  });
-});
-
-it('throws an error when the EdgeTarget element is missing', () => {
-  const n = new Node('id');
-  expect(
-    () => new Edge([] as unknown as EdgeTargetTuple),
-  ).toThrowErrorMatchingInlineSnapshot(
-    `[Error: The element of Edge target is missing or not satisfied as Edge target.]`,
-  );
-  expect(
-    () => new Edge([n] as unknown as EdgeTargetTuple),
-  ).toThrowErrorMatchingInlineSnapshot(
-    `[Error: The element of Edge target is missing or not satisfied as Edge target.]`,
-  );
-});

package/src/models/Edge.ts

@@ -1,40 +0,0 @@
-import {
-  AttributesGroupModel,
-  EdgeAttributeKey,
-  EdgeAttributesObject,
-  EdgeModel,
-  EdgeTargetTuple,
-  isNodeRefLike,
-} from '@ts-graphviz/common';
-import { AttributesGroup } from './AttributesGroup.js';
-import { DotObject } from './DotObject.js';
-
-/**
- * DOT object class representing a edge.
- * @group Models
- */
-export class Edge extends DotObject implements EdgeModel {
-  public get $$type(): 'Edge' {
-    return 'Edge';
-  }
-
-  public comment?: string;
-
-  public readonly attributes: AttributesGroupModel<EdgeAttributeKey>;
-
-  constructor(
-    public readonly targets: EdgeTargetTuple,
-    attributes?: EdgeAttributesObject,
-  ) {
-    super();
-    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);
-  }
-}

package/src/models/Graph.spec.ts

@@ -1,18 +0,0 @@
-import { expect, it, test } from 'vitest';
-import { DotObject } from './DotObject.js';
-import { Graph } from './Graph.js';
-import { GraphBase } from './GraphBase.js';
-
-import './registerModelContext.js';
-
-const g = new Graph();
-
-test('directed propaty should be false', () => {
-  expect(g.directed).toStrictEqual(false);
-});
-
-it('should be instance of Graph/GraphBase/DotObject', () => {
-  expect(g).toBeInstanceOf(Graph);
-  expect(g).toBeInstanceOf(GraphBase);
-  expect(g).toBeInstanceOf(DotObject);
-});

package/src/models/Graph.ts

@@ -1,11 +0,0 @@
-import { RootGraph } from './RootGraph.js';
-
-/**
- * DOT object class representing a graph.
- * @group Models
- */
-export class Graph extends RootGraph {
-  get directed(): boolean {
-    return false;
-  }
-}

package/src/models/GraphBase.spec.ts

@@ -1,364 +0,0 @@
-import { beforeEach, describe, expect, it, test, vi } from 'vitest';
-import './registerModelContext.js';
-
-import { EdgeTargetTuple, NodeModel } from '@ts-graphviz/common';
-import { attribute as _ } from '../attribute.js';
-import { AttributesBase } from './AttributesBase.js';
-import { DotObject } from './DotObject.js';
-import { Edge } from './Edge.js';
-import { GraphBase } from './GraphBase.js';
-import { Node } from './Node.js';
-import { Subgraph } from './Subgraph.js';
-
-class TestGraph extends GraphBase<any> {
-  public readonly directed = false;
-  public strict = true;
-}
-
-let g: TestGraph;
-beforeEach(() => {
-  g = new TestGraph();
-});
-
-it('should be instance of GraphBase/AttributesBase/DotObject', () => {
-  expect(g).toBeInstanceOf(GraphBase);
-  expect(g).toBeInstanceOf(AttributesBase);
-  expect(g).toBeInstanceOf(DotObject);
-});
-
-describe('Constructor', () => {
-  test('first argument is attributes object', () => {
-    const root = new TestGraph({
-      [_.label]: 'Label',
-    });
-    expect(root.size).toBe(1);
-    expect(root.get(_.label)).toBe('Label');
-  });
-});
-
-describe('Imperative API(addXxx existXxx removeXxx methods)', () => {
-  test('Node operation methods works', () => {
-    expect(g.existNode('foo')).toBe(false);
-    const node = new Node('foo');
-    g.addNode(node);
-    expect(g.existNode('foo')).toBe(true);
-    g.removeNode(node);
-    expect(g.existNode('foo')).toBe(false);
-    g.addNode(node);
-    expect(g.existNode('foo')).toBe(true);
-    g.removeNode('foo');
-    expect(g.existNode('foo')).toBe(false);
-  });
-
-  test('Edge operation methods works', () => {
-    const nodes = ['foo', 'bar'].map((id) =>
-      g.createNode(id),
-    ) as EdgeTargetTuple;
-    const edge = new Edge(nodes);
-    expect(g.existEdge(edge)).toBe(false);
-    g.addEdge(edge);
-    expect(g.existEdge(edge)).toBe(true);
-    g.removeEdge(edge);
-    expect(g.existEdge(edge)).toBe(false);
-  });
-
-  test('Subgraph operation methods works', () => {
-    const sub = g.createSubgraph('sub');
-    expect(g.existSubgraph(sub)).toBe(true);
-    g.removeSubgraph(sub);
-    expect(g.existSubgraph(sub)).toBe(false);
-    g.addSubgraph(sub);
-    expect(g.existSubgraph(sub)).toBe(true);
-    g.removeSubgraph(sub);
-    expect(g.existSubgraph(sub)).toBe(false);
-  });
-});
-
-describe('Declarative API', () => {
-  describe('node method', () => {
-    describe('create node if not exists', () => {
-      test('by id', () => {
-        const createNodeSpy = vi.spyOn(g, 'createNode');
-
-        g.node('foo');
-        expect(g.existNode('foo')).toBe(true);
-        expect(createNodeSpy).toHaveBeenCalledWith('foo');
-      });
-
-      test('with attributes', () => {
-        expect(g.existNode('foo')).toBe(false);
-        const createNodeSpy = vi.spyOn(g, 'createNode');
-
-        const node = g.node('foo', {
-          [_.label]: 'Test label',
-        });
-
-        expect(g.existNode('foo')).toBe(true);
-        expect(createNodeSpy).toHaveBeenCalledWith('foo');
-        expect(node.attributes.get(_.label)).toStrictEqual('Test label');
-      });
-
-      describe('callback function is given, the callback function is executed with the created node as the argument', () => {
-        test('first argument is id, seccond argument is callback', () => {
-          const callback = vi.fn();
-          const node = g.node('foo', callback);
-          expect(callback).toHaveBeenCalledWith(node);
-        });
-
-        test('first argument is id, seccond argument is attribute object, third argument is callback', () => {
-          const callback = vi.fn();
-          const node = g.node('foo', { [_.label]: 'Test label' }, callback);
-          expect(callback).toHaveBeenCalledWith(node);
-          expect(node.attributes.get(_.label)).toStrictEqual('Test label');
-        });
-      });
-    });
-
-    describe('get node if exists', () => {
-      test('by id', () => {
-        const createdNode = g.createNode('foo');
-        const createNodeSpy = vi.spyOn(g, 'createNode');
-
-        const returnedNode = g.node('foo');
-
-        expect(createNodeSpy).not.toHaveBeenCalled();
-        expect(returnedNode).toBe(createdNode);
-      });
-
-      test('with attributes', () => {
-        const createdNode = g.createNode('foo');
-        const createNodeSpy = vi.spyOn(g, 'createNode');
-
-        const returnedNode = g.node('foo', { [_.label]: 'Test label' });
-
-        expect(createNodeSpy).not.toHaveBeenCalled();
-        expect(returnedNode).toBe(createdNode);
-
-        expect(returnedNode.attributes.get(_.label)).toStrictEqual(
-          'Test label',
-        );
-      });
-
-      describe('callback function is given, the callback function is executed with the created node as the argument', () => {
-        let createdNode: NodeModel;
-        beforeEach(() => {
-          createdNode = g.createNode('foo');
-        });
-
-        test('first argument is id, seccond argument is callback', () => {
-          const callback = vi.fn();
-          const node = g.node('foo', callback);
-          expect(callback).toHaveBeenCalledWith(node);
-          expect(node).toBe(createdNode);
-        });
-
-        test('first argument is id, seccond argument is attribute object, third argument is callback', () => {
-          const callback = vi.fn();
-          const node = g.node('foo', { [_.label]: 'Test label' }, callback);
-          expect(callback).toHaveBeenCalledWith(node);
-          expect(node.attributes.get(_.label)).toStrictEqual('Test label');
-          expect(node).toBe(createdNode);
-        });
-      });
-    });
-
-    test('apply atttibutes to nodes in graph', () => {
-      g.node({ [_.label]: 'Test label' });
-      expect(g.attributes.node.get(_.label)).toStrictEqual('Test label');
-    });
-  });
-
-  describe('edge method', () => {
-    describe('create edge', () => {
-      let nodes: EdgeTargetTuple;
-      beforeEach(() => {
-        nodes = ['foo', 'bar'].map((id) => g.createNode(id)) as EdgeTargetTuple;
-      });
-
-      test('create edge with target nodes', () => {
-        const createEdgeSpy = vi.spyOn(g, 'createEdge');
-        g.edge(nodes);
-        expect(createEdgeSpy).toHaveBeenCalledWith(nodes, undefined);
-      });
-
-      test('create edge and apply attribute', () => {
-        const createEdgeSpy = vi.spyOn(g, 'createEdge');
-        g.edge(nodes, { [_.label]: 'Test label' });
-        expect(createEdgeSpy).toHaveBeenCalledWith(nodes, {
-          [_.label]: 'Test label',
-        });
-      });
-
-      test('apply atttibutes to edges in graph', () => {
-        g.edge({ [_.label]: 'Test label' });
-        expect(g.attributes.edge.get(_.label)).toStrictEqual('Test label');
-      });
-
-      describe('callback function is given, the callback function is executed with the created edge as the argument', () => {
-        test('first argument is id, seccond argument is callback', () => {
-          const callback = vi.fn();
-          const edge = g.edge(nodes, callback);
-          expect(callback).toHaveBeenCalledWith(edge);
-        });
-
-        test('first argument is id, seccond argument is attribute object, third argument is callback', () => {
-          const callback = vi.fn();
-          const edge = g.edge(nodes, { [_.label]: 'Test label' }, callback);
-          expect(callback).toHaveBeenCalledWith(edge);
-          expect(edge.attributes.get(_.label)).toStrictEqual('Test label');
-        });
-      });
-    });
-
-    test('apply atttibutes to edges in graph', () => {
-      g.edge({ [_.label]: 'Test label' });
-      expect(g.attributes.edge.get(_.label)).toStrictEqual('Test label');
-    });
-  });
-
-  describe('subgraph method', () => {
-    describe('create subgraph if not exists', () => {
-      test('no id', () => {
-        const createSubgraphSpy = vi.spyOn(g, 'createSubgraph');
-        const subgraph = g.subgraph();
-        expect(subgraph).toBeInstanceOf(Subgraph);
-        expect(createSubgraphSpy).toHaveBeenCalled();
-      });
-
-      test('only attributes', () => {
-        const createSubgraphSpy = vi.spyOn(g, 'createSubgraph');
-        const subgraph = g.subgraph({ [_.label]: 'Test label' });
-        expect(createSubgraphSpy).toHaveBeenCalled();
-        expect(subgraph.get(_.label)).toStrictEqual('Test label');
-      });
-
-      test('by id', () => {
-        const createSubgraphSpy = vi.spyOn(g, 'createSubgraph');
-        g.subgraph('foo');
-        expect(createSubgraphSpy).toHaveBeenCalledWith('foo');
-      });
-
-      test('with attributes', () => {
-        const createSubgraphSpy = vi.spyOn(g, 'createSubgraph');
-        const subgraph = g.subgraph('foo', { [_.label]: 'Test label' });
-        expect(createSubgraphSpy).toHaveBeenCalledWith('foo');
-        expect(subgraph.get(_.label)).toStrictEqual('Test label');
-      });
-
-      describe('callback function is given, the callback function is executed with the created subgraph as the argument', () => {
-        test('first argument is callback', () => {
-          const callback = vi.fn();
-          const subgraph = g.subgraph(callback);
-          expect(callback).toHaveBeenCalledWith(subgraph);
-        });
-
-        test('first argument is attribute, seccond argument is callback', () => {
-          const callback = vi.fn();
-          const subgraph = g.subgraph({ [_.label]: 'Test label' }, callback);
-          expect(callback).toHaveBeenCalledWith(subgraph);
-          expect(subgraph.get(_.label)).toStrictEqual('Test label');
-        });
-
-        test('first argument is id, seccond argument is callback', () => {
-          const callback = vi.fn();
-          const subgraph = g.subgraph('foo', callback);
-          expect(callback).toHaveBeenCalledWith(subgraph);
-        });
-
-        test('first argument is id, seccond argument is attribute object, third argument is callback', () => {
-          const callback = vi.fn();
-          const subgraph = g.subgraph(
-            'foo',
-            { [_.label]: 'Test label' },
-            callback,
-          );
-          expect(callback).toHaveBeenCalledWith(subgraph);
-          expect(subgraph.get(_.label)).toStrictEqual('Test label');
-        });
-      });
-    });
-
-    describe('get subgraph if exists', () => {
-      test('by id', () => {
-        const createdSubgraph = g.createSubgraph('foo');
-        const createSubgraphSpy = vi.spyOn(g, 'createSubgraph');
-
-        const returnedSubgraph = g.subgraph('foo');
-
-        expect(createSubgraphSpy).not.toHaveBeenCalled();
-        expect(returnedSubgraph).toBe(createdSubgraph);
-      });
-
-      test('with attributes', () => {
-        const createdSubgraph = g.createSubgraph('foo');
-        const createSubgraphSpy = vi.spyOn(g, 'createSubgraph');
-
-        const returnedSubgraph = g.subgraph('foo', { [_.label]: 'Test label' });
-
-        expect(createSubgraphSpy).not.toHaveBeenCalled();
-        expect(returnedSubgraph).toBe(createdSubgraph);
-
-        expect(returnedSubgraph.get(_.label)).toStrictEqual('Test label');
-      });
-    });
-  });
-
-  describe('graph method', () => {
-    test('apply atttibutes to graphs in graph', () => {
-      g.graph({ [_.label]: 'Test label' });
-      expect(g.attributes.graph.get(_.label)).toStrictEqual('Test label');
-    });
-  });
-});
-
-describe('Models Context API', () => {
-  class TestNode extends Node {}
-  class TestEdge extends Edge {}
-  class TestSubgraphA extends Subgraph {}
-  class TestSubgraphB extends Subgraph {}
-  class TestSubgraphC extends Subgraph {}
-
-  describe('By providing a context in the with method, the object created by createXxx is created with the model given by the context.', () => {
-    test('with TestNode', () => {
-      g.with({ Node: TestNode });
-
-      const node = g.createNode('hoge');
-      expect(node).toBeInstanceOf(TestNode);
-    });
-
-    test('with TestEdge', () => {
-      g.with({ Edge: TestEdge });
-
-      const edge = g.createEdge(['foo', 'bar']);
-      expect(edge).toBeInstanceOf(TestEdge);
-    });
-
-    test('with TestSubgraph', () => {
-      g.with({ Subgraph: TestSubgraphA });
-
-      const subgraph = g.createSubgraph();
-      expect(subgraph).toBeInstanceOf(TestSubgraphA);
-    });
-
-    test('In nested contexts, the settings are inherited. It also does not affect the parent context.', () => {
-      const sub = g.createSubgraph();
-      expect(sub).toBeInstanceOf(Subgraph);
-
-      sub.with({ Subgraph: TestSubgraphA });
-      const A = sub.createSubgraph();
-      expect(A).toBeInstanceOf(TestSubgraphA);
-
-      A.with({ Subgraph: TestSubgraphB });
-      const B = A.createSubgraph();
-      expect(B).toBeInstanceOf(TestSubgraphB);
-
-      B.with({ Subgraph: TestSubgraphC });
-      const C = B.createSubgraph();
-      expect(C).toBeInstanceOf(TestSubgraphC);
-
-      expect(sub.createSubgraph()).toBeInstanceOf(TestSubgraphA);
-      expect(A.createSubgraph()).toBeInstanceOf(TestSubgraphB);
-      expect(B.createSubgraph()).toBeInstanceOf(TestSubgraphC);
-    });
-  });
-});