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

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);
-    });
-  });
-});

package/src/models/GraphBase.ts

@@ -1,263 +0,0 @@
-import {
-  AttributeKey,
-  ClusterSubgraphAttributeKey,
-  EdgeAttributeKey,
-  EdgeAttributesObject,
-  EdgeModel,
-  EdgeTargetLikeTuple,
-  EdgeTargetTuple,
-  GraphBaseModel,
-  GraphCommonAttributes,
-  ModelsContext,
-  NodeAttributeKey,
-  NodeAttributesObject,
-  NodeModel,
-  RootModelsContext,
-  SubgraphAttributeKey,
-  SubgraphAttributesObject,
-  SubgraphModel,
-  createModelsContext,
-  isNodeRefGroupLike,
-  toNodeRef,
-  toNodeRefGroup,
-} from '@ts-graphviz/common';
-import { AttributeList } from './AttributeList.js';
-import { AttributesBase } from './AttributesBase.js';
-
-/**
- * Base class for Graph objects.
- * @group Models
- */
-export abstract class GraphBase<T extends AttributeKey>
-  extends AttributesBase<T>
-  implements GraphBaseModel<T>
-{
-  /** @hidden */
-  #models = RootModelsContext;
-
-  public readonly id?: string;
-
-  public comment?: string;
-
-  public readonly attributes: Readonly<GraphCommonAttributes> = Object.freeze({
-    graph: new AttributeList<
-      'Graph',
-      SubgraphAttributeKey | ClusterSubgraphAttributeKey
-    >('Graph'),
-    edge: new AttributeList<'Edge', EdgeAttributeKey>('Edge'),
-    node: new AttributeList<'Node', NodeAttributeKey>('Node'),
-  });
-
-  get nodes(): ReadonlyArray<NodeModel> {
-    return Array.from(this.#objects.nodes.values());
-  }
-
-  get edges(): ReadonlyArray<EdgeModel> {
-    return Array.from(this.#objects.edges.values());
-  }
-
-  get subgraphs(): ReadonlyArray<SubgraphModel> {
-    return Array.from(this.#objects.subgraphs.values());
-  }
-
-  /** @hidden */
-  #objects: Readonly<{
-    nodes: Map<string, NodeModel>;
-    edges: Set<EdgeModel>;
-    subgraphs: Set<SubgraphModel>;
-  }> = {
-    nodes: new Map(),
-    edges: new Set(),
-    subgraphs: new Set(),
-  };
-
-  public with(models: Partial<ModelsContext>): void {
-    this.#models = createModelsContext(models);
-  }
-
-  public addNode(node: NodeModel): void {
-    this.#objects.nodes.set(node.id, node);
-  }
-
-  public addEdge(edge: EdgeModel): void {
-    this.#objects.edges.add(edge);
-  }
-
-  public addSubgraph(subgraph: SubgraphModel): void {
-    this.#objects.subgraphs.add(subgraph);
-  }
-
-  public existNode(nodeId: string): boolean {
-    return this.#objects.nodes.has(nodeId);
-  }
-
-  public existEdge(edge: EdgeModel): boolean {
-    return this.#objects.edges.has(edge);
-  }
-
-  public existSubgraph(subgraph: SubgraphModel): boolean {
-    return this.#objects.subgraphs.has(subgraph);
-  }
-
-  public createSubgraph(
-    id?: string,
-    attributes?: SubgraphAttributesObject,
-  ): SubgraphModel;
-
-  public createSubgraph(attributes?: SubgraphAttributesObject): SubgraphModel;
-
-  public createSubgraph(...args: unknown[]): SubgraphModel {
-    const subgraph = new this.#models.Subgraph(...args);
-    subgraph.with(this.#models);
-    this.addSubgraph(subgraph);
-    return subgraph;
-  }
-
-  public removeNode(node: NodeModel | string): void {
-    this.#objects.nodes.delete(typeof node === 'string' ? node : node.id);
-  }
-
-  public removeEdge(edge: EdgeModel): void {
-    this.#objects.edges.delete(edge);
-  }
-
-  public removeSubgraph(subgraph: SubgraphModel): void {
-    this.#objects.subgraphs.delete(subgraph);
-  }
-
-  public createNode(id: string, attributes?: NodeAttributesObject): NodeModel {
-    const node = new this.#models.Node(id, attributes);
-    this.addNode(node);
-    return node;
-  }
-
-  public getSubgraph(id: string): SubgraphModel | undefined {
-    return Array.from(this.#objects.subgraphs.values()).find(
-      (subgraph) => subgraph.id === id,
-    );
-  }
-
-  public getNode(id: string): NodeModel | undefined {
-    return this.#objects.nodes.get(id);
-  }
-
-  public createEdge(
-    targets: EdgeTargetLikeTuple,
-    attributes?: EdgeAttributesObject,
-  ): EdgeModel {
-    const ts = targets.map((t) =>
-      isNodeRefGroupLike(t) ? toNodeRefGroup(t) : toNodeRef(t),
-    ) as EdgeTargetTuple;
-    const edge = new this.#models.Edge(ts, attributes);
-    this.addEdge(edge);
-    return edge;
-  }
-
-  public subgraph(
-    id: string,
-    callback?: (subgraph: SubgraphModel) => void,
-  ): SubgraphModel;
-  public subgraph(
-    id: string,
-    attributes: SubgraphAttributesObject,
-    callback?: (subgraph: SubgraphModel) => void,
-  ): SubgraphModel;
-  public subgraph(
-    attributes: SubgraphAttributesObject,
-    callback?: (subgraph: SubgraphModel) => void,
-  ): SubgraphModel;
-  public subgraph(callback?: (subgraph: SubgraphModel) => void): SubgraphModel;
-  public subgraph(...args: unknown[]): SubgraphModel {
-    const id = args.find(
-      (arg: unknown): arg is string => typeof arg === 'string',
-    );
-    const attributes = args.find(
-      (arg: unknown): arg is SubgraphAttributesObject =>
-        typeof arg === 'object' && arg !== null,
-    );
-    const callback = args.find(
-      (arg: unknown): arg is (subgraph: SubgraphModel) => void =>
-        typeof arg === 'function',
-    );
-    const subgraph: SubgraphModel = id
-      ? this.getSubgraph(id) ?? this.createSubgraph(id)
-      : this.createSubgraph();
-    if (attributes !== undefined) {
-      subgraph.apply(attributes);
-    }
-    if (callback !== undefined) {
-      callback(subgraph);
-    }
-    return subgraph;
-  }
-
-  public node(id: string, callback?: (node: NodeModel) => void): NodeModel;
-  public node(
-    id: string,
-    attributes: NodeAttributesObject,
-    callback?: (node: NodeModel) => void,
-  ): NodeModel;
-  public node(attributes: NodeAttributesObject): void;
-  public node(firstArg: unknown, ...args: unknown[]): NodeModel | undefined {
-    if (typeof firstArg === 'string') {
-      const id = firstArg;
-      const attributes = args.find(
-        (arg: unknown): arg is NodeAttributesObject =>
-          typeof arg === 'object' && arg !== null,
-      );
-      const callback = args.find(
-        (arg: unknown): arg is (node: NodeModel) => void =>
-          typeof arg === 'function',
-      );
-      const node = this.getNode(id) ?? this.createNode(id);
-      if (attributes !== undefined) {
-        node.attributes.apply(attributes);
-      }
-      if (callback !== undefined) {
-        callback(node);
-      }
-      return node;
-    }
-    if (typeof firstArg === 'object' && firstArg !== null) {
-      this.attributes.node.apply(firstArg);
-    }
-  }
-
-  public edge(
-    targets: EdgeTargetLikeTuple,
-    callback?: (edge: EdgeModel) => void,
-  ): EdgeModel;
-  public edge(
-    targets: EdgeTargetLikeTuple,
-    attributes: EdgeAttributesObject,
-    callback?: (edge: EdgeModel) => void,
-  ): EdgeModel;
-  public edge(attributes: EdgeAttributesObject): void;
-  public edge(
-    firstArg: EdgeTargetLikeTuple | EdgeAttributesObject,
-    ...args: unknown[]
-  ): EdgeModel | undefined {
-    if (Array.isArray(firstArg)) {
-      const targets = firstArg;
-      const attributes = args.find(
-        (arg: unknown): arg is EdgeAttributesObject => typeof arg === 'object',
-      );
-      const callback = args.find(
-        (arg: unknown): arg is (edge: EdgeModel) => void =>
-          typeof arg === 'function',
-      );
-      const edge = this.createEdge(targets, attributes);
-      if (callback !== undefined) {
-        callback(edge);
-      }
-      return edge;
-    }
-    if (typeof firstArg === 'object' && firstArg !== null) {
-      this.attributes.edge.apply(firstArg);
-    }
-  }
-
-  public graph(attributes: SubgraphAttributesObject): void {
-    this.attributes.graph.apply(attributes);
-  }
-}

package/src/models/Node.spec.ts

@@ -1,25 +0,0 @@
-import { beforeEach, describe, expect, it, test } from 'vitest';
-import { attribute as _ } from '../attribute.js';
-import { DotObject } from './DotObject.js';
-import { Node } from './Node.js';
-
-let node: Node;
-beforeEach(() => {
-  node = new Node('test');
-});
-
-describe('Constructor', () => {
-  test('first argument is id, and second attributes object', () => {
-    node = new Node('test', {
-      [_.label]: 'Label',
-    });
-    expect(node.id).toBe('test');
-    expect(node.attributes.size).toBe(1);
-    expect(node.attributes.get(_.label)).toBe('Label');
-  });
-});
-
-it('should be instance of Node/DotObject', () => {
-  expect(node).toBeInstanceOf(Node);
-  expect(node).toBeInstanceOf(DotObject);
-});