@ts-graphviz/core 0.0.0-pr956-20240225073457

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

@@ -0,0 +1,61 @@
+import { describe, expect, test } from 'vitest';
+import { Digraph, Graph } from '../models/index.js';
+import { digraph, graph, strict, withContext } from './model-factory.js';
+
+test('digraph function returns an object of Digraph, and the strict property is false', () => {
+  const g = digraph();
+  expect(g).toBeInstanceOf(Digraph);
+  expect(g.strict).toStrictEqual(false);
+});
+
+test('graph function returns an object of Graph, and the strict property is false', () => {
+  const g = graph();
+  expect(g).toBeInstanceOf(Graph);
+  expect(g.strict).toStrictEqual(false);
+});
+
+test('strict.digraph function returns an object of Digraph', () => {
+  const g = strict.digraph();
+  expect(g).toBeInstanceOf(Digraph);
+  expect(g.strict).toStrictEqual(true);
+});
+
+test('strict.graph function returns an object of Graph', () => {
+  const g = strict.graph();
+  expect(g).toBeInstanceOf(Graph);
+  expect(g.strict).toStrictEqual(true);
+});
+
+describe('withContext function allows the class RootGraph to be generated with a custom class.', () => {
+  class TestDigraph extends Digraph {}
+  class TestGraph extends Graph {}
+
+  const { digraph, graph, strict } = withContext({
+    Digraph: TestDigraph,
+    Graph: TestGraph,
+  });
+
+  test('digraph function returns an object of TestDigraph, and the strict property is false', () => {
+    const g = digraph();
+    expect(g).toBeInstanceOf(TestDigraph);
+    expect(g.strict).toStrictEqual(false);
+  });
+
+  test('graph function returns an object of TestGraph, and the strict property is false', () => {
+    const g = graph();
+    expect(g).toBeInstanceOf(TestGraph);
+    expect(g.strict).toStrictEqual(false);
+  });
+
+  test('strict.digraph function returns an object of TestDigraph', () => {
+    const g = strict.digraph();
+    expect(g).toBeInstanceOf(TestDigraph);
+    expect(g.strict).toStrictEqual(true);
+  });
+
+  test('strict.graph function returns an object of TestGraph', () => {
+    const g = strict.graph();
+    expect(g).toBeInstanceOf(TestGraph);
+    expect(g.strict).toStrictEqual(true);
+  });
+});

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

@@ -0,0 +1,40 @@
+import { ModelsContext, createModelsContext } from '@ts-graphviz/common';
+import { createModelFactories } from './model-factory-builder.js';
+import { ModelFactories, ModelFactoriesWithStrict } from './types.js';
+
+const noStrict: ModelFactories = createModelFactories(false);
+
+/**
+ *  digraph is a factory for creating Digraph objects.
+ * @group Model Factory
+ */
+export const digraph = noStrict.digraph;
+
+/**
+ * graph is a factory for creating Graph objects.
+ * @group Model Factory
+ */
+export const graph = noStrict.graph;
+
+/**
+ * Provides a strict mode API.
+ * @group Model Factory
+ */
+export const strict: ModelFactories = createModelFactories(true);
+
+/**
+ * withContext creates a {@link ModelFactoriesWithStrict} object with the given context.
+ *
+ * @param models - An object containing the models to be used in the context.
+ *
+ * @returns A ModelFactoriesWithStrict object containing the factories. * @group Model Factory
+ */
+export function withContext(
+  models: Partial<ModelsContext>,
+): ModelFactoriesWithStrict {
+  const context = createModelsContext(models);
+  return Object.freeze({
+    ...createModelFactories(false, context),
+    strict: createModelFactories(true, context),
+  });
+}

package/src/model-factory/types.ts

@@ -0,0 +1,46 @@
+import { GraphAttributesObject, RootGraphModel } from '@ts-graphviz/common';
+
+/**
+ * ModelFactory is an interface that provides a way to create a {@link RootGraphModel} object.
+ *
+ * @param id - Optional string parameter that specifies the id of the {@link RootGraphModel} object.
+ * @param attributes - Optional GraphAttributesObject parameter that specifies the attributes of the {@link RootGraphModel} object.
+ * @param callback - Optional callback function that takes a {@link RootGraphModel} object as a parameter.
+ *
+ * @returns {@link RootGraphModel} - Returns a {@link RootGraphModel} object.
+ * @group Model Factory
+ */
+export interface ModelFactory {
+  (
+    id?: string,
+    attributes?: GraphAttributesObject,
+    callback?: (g: RootGraphModel) => void,
+  ): RootGraphModel;
+  (
+    attributes?: GraphAttributesObject,
+    callback?: (g: RootGraphModel) => void,
+  ): RootGraphModel;
+  (id?: string, callback?: (g: RootGraphModel) => void): RootGraphModel;
+  (callback?: (g: RootGraphModel) => void): RootGraphModel;
+}
+
+/**
+ * @group Model Factory
+ */
+export interface ModelFactories {
+  /**
+   * API for creating directional graph objects.
+   */
+  digraph: ModelFactory;
+  /**
+   * API for creating omnidirectional graph objects.
+   */
+  graph: ModelFactory;
+}
+
+/**
+ * @group Model Factory
+ */
+export interface ModelFactoriesWithStrict extends ModelFactories {
+  strict: ModelFactories;
+}

package/src/models/AttributeList.spec.ts

@@ -0,0 +1,58 @@
+import { AttributeListKind } from '@ts-graphviz/common';
+import { beforeEach, describe, expect, it, test } from 'vitest';
+import { attribute as _ } from '../attribute.js';
+import { AttributeList } from './AttributeList.js';
+import { AttributesBase } from './AttributesBase.js';
+import { DotObject } from './DotObject.js';
+
+let attrs: AttributeList<AttributeListKind>;
+beforeEach(() => {
+  attrs = new AttributeList('Node');
+});
+
+describe('object', () => {
+  it('should be instance of AttributeList/AttributesBase/DotObject', () => {
+    expect(attrs).toBeInstanceOf(AttributeList);
+    expect(attrs).toBeInstanceOf(AttributesBase);
+    expect(attrs).toBeInstanceOf(DotObject);
+  });
+
+  it('size should be 0 by default', () => {
+    expect(attrs.size).toBe(0);
+  });
+
+  it('$$type property should returns "AttributeList"', () => {
+    expect(attrs.$$type).toStrictEqual('AttributeList');
+  });
+});
+
+describe('constructor', () => {
+  describe('1st argument is kind of AttributeList', () => {
+    test.each(['Node', 'Edge', 'Graph'] as AttributeListKind[])(
+      'AttributeList kind is %s',
+      (kind) => {
+        attrs = new AttributeList(kind);
+        expect(attrs.$$kind).toStrictEqual(kind);
+      },
+    );
+  });
+
+  test('2nd argument is attribute object', () => {
+    attrs = new AttributeList('Node', {
+      [_.label]: 'Label',
+    });
+    expect(attrs.size).toBe(1);
+    expect(attrs.get(_.label)).toBe('Label');
+  });
+});
+
+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/AttributeList.ts

@@ -0,0 +1,32 @@
+import {
+  AttributeKey,
+  AttributeListKind,
+  AttributeListModel,
+  AttributesObject,
+} from '@ts-graphviz/common';
+import { AttributesBase } from './AttributesBase.js';
+
+/**
+ * A set of attribute values for any object.
+ * @group Models
+ */
+export class AttributeList<
+    K extends AttributeListKind,
+    T extends AttributeKey = AttributeKey,
+  >
+  extends AttributesBase<T>
+  implements AttributeListModel<K, T>
+{
+  public get $$type(): 'AttributeList' {
+    return 'AttributeList';
+  }
+
+  public comment?: string;
+
+  constructor(
+    public readonly $$kind: K,
+    attributes?: AttributesObject<T>,
+  ) {
+    super(attributes);
+  }
+}

package/src/models/AttributesBase.spec.ts

@@ -0,0 +1,79 @@
+import { Attributes } from '@ts-graphviz/common';
+import { beforeEach, describe, expect, it, test } from 'vitest';
+import { attribute as _ } from '../attribute.js';
+import { AttributesBase } from './AttributesBase.js';
+import { DotObject } from './DotObject.js';
+
+class TestAttributes extends AttributesBase<any> {}
+
+let attrs: Attributes<any>;
+beforeEach(() => {
+  attrs = new TestAttributes();
+});
+
+describe('object', () => {
+  it('should be instance of AttributesBase/DotObject', () => {
+    expect(attrs).toBeInstanceOf(DotObject);
+    expect(attrs).toBeInstanceOf(AttributesBase);
+  });
+
+  it('size should be 0 by default', () => {
+    expect(attrs.size).toBe(0);
+  });
+});
+
+describe('constructor', () => {
+  test('with no attribute object', () => {
+    attrs = new TestAttributes();
+    expect(attrs.size).toBe(0);
+    expect(attrs.get(_.label)).toBeUndefined();
+  });
+
+  test('with attribute object', () => {
+    attrs = new TestAttributes({
+      [_.label]: 'Label',
+    });
+    expect(attrs.size).toBe(1);
+    expect(attrs.get(_.label)).toBe('Label');
+  });
+});
+
+describe('apply method', () => {
+  test('with attributes object', () => {
+    attrs.apply({
+      [_.label]: 'this is test',
+      [_.color]: 'red',
+      [_.fontsize]: 16,
+    });
+    expect(attrs.size).toBe(3);
+  });
+
+  test('with attributes entities', () => {
+    attrs.apply([
+      [_.label, 'this is test'],
+      [_.color, 'red'],
+      [_.fontsize, 16],
+    ]);
+    expect(attrs.size).toBe(3);
+  });
+});
+
+test('clear method', () => {
+  attrs = new TestAttributes({
+    [_.label]: 'this is test',
+    [_.color]: 'red',
+    [_.fontsize]: 16,
+  });
+
+  expect(attrs.size).toBe(3);
+  attrs.clear();
+  expect(attrs.size).toBe(0);
+});
+
+test('set/get/delete methods', () => {
+  const id = 'test';
+  attrs.set('label', id);
+  expect(attrs.get('label')).toBe(id);
+  attrs.delete('label');
+  expect(attrs.get('label')).toBeUndefined();
+});

package/src/models/AttributesBase.ts

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

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

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

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

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

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

package/src/models/Edge.spec.ts

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

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

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

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