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

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

package/src/models/Node.ts

@@ -1,37 +0,0 @@
-import {
-  ForwardRefNode,
-  NodeAttributeKey,
-  NodeAttributesObject,
-  NodeModel,
-  Port,
-} from '@ts-graphviz/common';
-import { AttributesGroup } from './AttributesGroup.js';
-import { DotObject } from './DotObject.js';
-
-/**
- * DOT object class representing a node.
- * @group Models
- */
-export class Node extends DotObject implements NodeModel {
-  public get $$type(): 'Node' {
-    return 'Node';
-  }
-  public comment?: string;
-
-  public readonly attributes: AttributesGroup<NodeAttributeKey>;
-
-  constructor(
-    public readonly id: string,
-    attributes?: NodeAttributesObject,
-  ) {
-    super();
-    this.attributes = new AttributesGroup(attributes);
-  }
-
-  public port(port: string | Partial<Port>): ForwardRefNode {
-    if (typeof port === 'string') {
-      return { id: this.id, port };
-    }
-    return { id: this.id, ...port };
-  }
-}

package/src/models/RootGraph.spec.ts

@@ -1,69 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,196 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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';