ts-graphviz 1.8.2 → 2.0.0

package/lib/core/index.d.ts

@@ -1,347 +0,0 @@
-import {
-  Attribute,
-  AttributeKey,
-  Attributes,
-  AttributesObject,
-  AttributesEntities,
-  AttributeListKind,
-  AttributeListModel,
-  AttributesGroupModel,
-  GraphBaseModel,
-  GraphCommonAttributes,
-  NodeModel,
-  EdgeModel,
-  SubgraphModel,
-  ModelsContext,
-  SubgraphAttributesObject,
-  NodeAttributesObject,
-  EdgeTargetLikeTuple,
-  EdgeAttributesObject,
-  GraphAttributeKey,
-  RootGraphModel,
-  GraphAttributesObject,
-  EdgeTargetTuple,
-  EdgeAttributeKey,
-  NodeAttributeKey,
-  Port,
-  ForwardRefNode,
-  SubgraphAttributeKey,
-  ClusterSubgraphAttributeKey,
-  DotObjectModel,
-} from '../common/index.js';
-import { ConvertFromModelOptions, PrintOptions, ParseOptions, ConvertToModelOptions } from '../ast/index.js';
-
-/**
- * @group Attribute
- *
- * @deprecated Use {@link Attribute.keys} instead.
- */
-type AttributeKeyDict = Attribute.keys;
-/**
- * @group Attribute
- */
-declare const attribute: Attribute.keys;
-
-/**
- * Base class for DOT objects.
- * @group Models
- */
-declare abstract class DotObject {}
-
-/**
- * Base class for DOT objects with attributes.
- * @group Models
- */
-declare abstract class AttributesBase<T extends AttributeKey> extends DotObject implements Attributes<T> {
-  #private;
-  constructor(attributes?: AttributesObject<T>);
-  get values(): ReadonlyArray<[T, Attribute<T>]>;
-  get size(): number;
-  get<K extends T>(key: K): Attribute<K> | undefined;
-  set<K extends T>(key: K, value: Attribute<K>): void;
-  delete(key: T): void;
-  apply(attributes: AttributesObject<T> | AttributesEntities<T>): void;
-  clear(): void;
-}
-
-/**
- * A set of attribute values for any object.
- * @group Models
- */
-declare class AttributeList<K extends AttributeListKind, T extends AttributeKey = AttributeKey>
-  extends AttributesBase<T>
-  implements AttributeListModel<K, T>
-{
-  readonly $$kind: K;
-  get $$type(): 'AttributeList';
-  comment?: string;
-  constructor($$kind: K, attributes?: AttributesObject<T>);
-}
-
-/**
- * A set of attribute values for any object.
- * @group Models
- */
-declare class AttributesGroup<T extends AttributeKey = AttributeKey>
-  extends AttributesBase<T>
-  implements AttributesGroupModel<T>
-{
-  comment?: string;
-}
-
-/**
- * Base class for Graph objects.
- * @group Models
- */
-declare abstract class GraphBase<T extends AttributeKey> extends AttributesBase<T> implements GraphBaseModel<T> {
-  #private;
-  readonly id?: string;
-  comment?: string;
-  readonly attributes: Readonly<GraphCommonAttributes>;
-  get nodes(): ReadonlyArray<NodeModel>;
-  get edges(): ReadonlyArray<EdgeModel>;
-  get subgraphs(): ReadonlyArray<SubgraphModel>;
-  with(models: Partial<ModelsContext>): void;
-  addNode(node: NodeModel): void;
-  addEdge(edge: EdgeModel): void;
-  addSubgraph(subgraph: SubgraphModel): void;
-  existNode(nodeId: string): boolean;
-  existEdge(edge: EdgeModel): boolean;
-  existSubgraph(subgraph: SubgraphModel): boolean;
-  createSubgraph(id?: string, attributes?: SubgraphAttributesObject): SubgraphModel;
-  createSubgraph(attributes?: SubgraphAttributesObject): SubgraphModel;
-  removeNode(node: NodeModel | string): void;
-  removeEdge(edge: EdgeModel): void;
-  removeSubgraph(subgraph: SubgraphModel): void;
-  createNode(id: string, attributes?: NodeAttributesObject): NodeModel;
-  getSubgraph(id: string): SubgraphModel | undefined;
-  getNode(id: string): NodeModel | undefined;
-  createEdge(targets: EdgeTargetLikeTuple, attributes?: EdgeAttributesObject): EdgeModel;
-  subgraph(id: string, callback?: (subgraph: SubgraphModel) => void): SubgraphModel;
-  subgraph(
-    id: string,
-    attributes: SubgraphAttributesObject,
-    callback?: (subgraph: SubgraphModel) => void,
-  ): SubgraphModel;
-  subgraph(attributes: SubgraphAttributesObject, callback?: (subgraph: SubgraphModel) => void): SubgraphModel;
-  subgraph(callback?: (subgraph: SubgraphModel) => void): SubgraphModel;
-  node(id: string, callback?: (node: NodeModel) => void): NodeModel;
-  node(id: string, attributes: NodeAttributesObject, callback?: (node: NodeModel) => void): NodeModel;
-  node(attributes: NodeAttributesObject): void;
-  edge(targets: EdgeTargetLikeTuple, callback?: (edge: EdgeModel) => void): EdgeModel;
-  edge(targets: EdgeTargetLikeTuple, attributes: EdgeAttributesObject, callback?: (edge: EdgeModel) => void): EdgeModel;
-  edge(attributes: EdgeAttributesObject): void;
-  graph(attributes: SubgraphAttributesObject): void;
-}
-
-/**
- * Base class representing a root graph(digraph, graph).
- * @group Models
- */
-declare abstract class RootGraph extends GraphBase<GraphAttributeKey> implements RootGraphModel {
-  get $$type(): 'Graph';
-  readonly id?: string;
-  abstract readonly directed: boolean;
-  strict: boolean;
-  constructor(id?: string, attributes?: GraphAttributesObject);
-  constructor(id?: string, strict?: boolean, attributes?: GraphAttributesObject);
-  constructor(strict?: boolean, attributes?: GraphAttributesObject);
-  constructor(attributes?: GraphAttributesObject);
-}
-
-/**
- * DOT object class representing a digraph.
- * @group Models
- */
-declare class Digraph extends RootGraph {
-  get directed(): boolean;
-}
-
-/**
- * DOT object class representing a edge.
- * @group Models
- */
-declare class Edge extends DotObject implements EdgeModel {
-  readonly targets: EdgeTargetTuple;
-  get $$type(): 'Edge';
-  comment?: string;
-  readonly attributes: AttributesGroupModel<EdgeAttributeKey>;
-  constructor(targets: EdgeTargetTuple, attributes?: EdgeAttributesObject);
-}
-
-/**
- * DOT object class representing a graph.
- * @group Models
- */
-declare class Graph extends RootGraph {
-  get directed(): boolean;
-}
-
-/**
- * DOT object class representing a node.
- * @group Models
- */
-declare class Node extends DotObject implements NodeModel {
-  readonly id: string;
-  get $$type(): 'Node';
-  comment?: string;
-  readonly attributes: AttributesGroup<NodeAttributeKey>;
-  constructor(id: string, attributes?: NodeAttributesObject);
-  port(port: string | Partial<Port>): ForwardRefNode;
-}
-
-/**
- * DOT object class representing a subgraph.
- * @group Models
- */
-declare class Subgraph extends GraphBase<SubgraphAttributeKey | ClusterSubgraphAttributeKey> implements SubgraphModel {
-  get $$type(): 'Subgraph';
-  readonly id?: string;
-  constructor(id?: string, attributes?: SubgraphAttributesObject);
-  constructor(attributes?: SubgraphAttributesObject);
-  isSubgraphCluster(): boolean;
-}
-
-/**
- * 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
- */
-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
- */
-interface ModelFactories {
-  /**
-   * API for creating directional graph objects.
-   */
-  digraph: ModelFactory;
-  /**
-   * API for creating omnidirectional graph objects.
-   */
-  graph: ModelFactory;
-}
-/**
- * @group Model Factory
- */
-interface ModelFactoriesWithStrict extends ModelFactories {
-  strict: ModelFactories;
-}
-
-/**
- *  digraph is a factory for creating Digraph objects.
- * @group Model Factory
- */
-declare const digraph: ModelFactory;
-/**
- * graph is a factory for creating Graph objects.
- * @group Model Factory
- */
-declare const graph: ModelFactory;
-/**
- * Provides a strict mode API.
- * @group Model Factory
- */
-declare const strict: ModelFactories;
-/**
- * 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
- */
-declare function withContext(models: Partial<ModelsContext>): ModelFactoriesWithStrict;
-
-/**
- * This interface provides options for converting a model to DOT.
- * @group Convert Model to DOT
- * @alpha
- */
-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
- */
-declare function toDot(model: DotObjectModel, options?: ToDotOptions): string;
-
-/**
- * This interface provides options for converting DOT to a model.
- * @group Convert DOT to Model
- * @alpha
- */
-interface FromDotOptions<T extends 'Dot' | 'Graph' | 'Node' | 'Edge' | 'Subgraph'> {
-  /**
-   * Options for parsing DOT.
-   */
-  parse?: ParseOptions<T>;
-  /**
-   * Options for converting the parsed DOT to a model.
-   */
-  convert?: ConvertToModelOptions;
-}
-/**
- * fromDot is a function that converts a DOT string to a model.
- *
- * @group Convert DOT to Model
- *
- * @param dot The DOT string to convert.
- * @param options Options for converting the DOT string to a model.
- * @returns A model of type {@link RootGraphModel}, {@link NodeModel}, {@link EdgeModel}, or {@link SubgraphModel},
- * depending on the type specified in the options.
- * @beta
- */
-declare function fromDot(dot: string, options?: FromDotOptions<'Dot' | 'Graph'>): RootGraphModel;
-declare function fromDot(dot: string, options?: FromDotOptions<'Node'>): NodeModel;
-declare function fromDot(dot: string, options?: FromDotOptions<'Edge'>): EdgeModel;
-declare function fromDot(dot: string, options?: FromDotOptions<'Subgraph'>): SubgraphModel;
-
-export {
-  AttributeKeyDict,
-  AttributeList,
-  AttributesBase,
-  AttributesGroup,
-  Digraph,
-  DotObject,
-  Edge,
-  FromDotOptions,
-  Graph,
-  GraphBase,
-  ModelFactories,
-  ModelFactoriesWithStrict,
-  ModelFactory,
-  Node,
-  RootGraph,
-  Subgraph,
-  ToDotOptions,
-  attribute,
-  digraph,
-  fromDot,
-  graph,
-  strict,
-  toDot,
-  withContext,
-};

package/lib/core/index.js

@@ -1,364 +0,0 @@
-import {
-  RootModelsContext,
-  createModelsContext,
-  isNodeRefGroupLike,
-  toNodeRefGroup,
-  toNodeRef,
-  isNodeRefLike,
-} from '../common/index.js';
-import { fromModel, stringify, parse, toModel } from '../ast/index.js';
-
-const attribute = new Proxy(Object.freeze({}), {
-  get: (_, key) => key,
-});
-
-class DotObject {}
-
-class AttributesBase extends DotObject {
-  #attrs = new Map();
-  constructor(attributes) {
-    super();
-    if (attributes !== undefined) {
-      this.apply(attributes);
-    }
-  }
-  get values() {
-    return Array.from(this.#attrs.entries());
-  }
-  get size() {
-    return this.#attrs.size;
-  }
-  get(key) {
-    return this.#attrs.get(key);
-  }
-  set(key, value) {
-    if (value !== null && value !== undefined) {
-      this.#attrs.set(key, value);
-    }
-  }
-  delete(key) {
-    this.#attrs.delete(key);
-  }
-  apply(attributes) {
-    const entries = Array.isArray(attributes) ? attributes : Object.entries(attributes);
-    for (const [key, value] of entries) {
-      this.set(key, value);
-    }
-  }
-  clear() {
-    this.#attrs.clear();
-  }
-}
-
-class AttributeList extends AttributesBase {
-  $$kind;
-  get $$type() {
-    return 'AttributeList';
-  }
-  comment;
-  constructor($$kind, attributes) {
-    super(attributes);
-    this.$$kind = $$kind;
-  }
-}
-
-class GraphBase extends AttributesBase {
-  #models = RootModelsContext;
-  id;
-  comment;
-  attributes = Object.freeze({
-    graph: new AttributeList('Graph'),
-    edge: new AttributeList('Edge'),
-    node: new AttributeList('Node'),
-  });
-  get nodes() {
-    return Array.from(this.#objects.nodes.values());
-  }
-  get edges() {
-    return Array.from(this.#objects.edges.values());
-  }
-  get subgraphs() {
-    return Array.from(this.#objects.subgraphs.values());
-  }
-  #objects = {
-    nodes: new Map(),
-    edges: new Set(),
-    subgraphs: new Set(),
-  };
-  with(models) {
-    this.#models = createModelsContext(models);
-  }
-  addNode(node) {
-    this.#objects.nodes.set(node.id, node);
-  }
-  addEdge(edge) {
-    this.#objects.edges.add(edge);
-  }
-  addSubgraph(subgraph) {
-    this.#objects.subgraphs.add(subgraph);
-  }
-  existNode(nodeId) {
-    return this.#objects.nodes.has(nodeId);
-  }
-  existEdge(edge) {
-    return this.#objects.edges.has(edge);
-  }
-  existSubgraph(subgraph) {
-    return this.#objects.subgraphs.has(subgraph);
-  }
-  createSubgraph(...args) {
-    const subgraph = new this.#models.Subgraph(...args);
-    subgraph.with(this.#models);
-    this.addSubgraph(subgraph);
-    return subgraph;
-  }
-  removeNode(node) {
-    this.#objects.nodes.delete(typeof node === 'string' ? node : node.id);
-  }
-  removeEdge(edge) {
-    this.#objects.edges.delete(edge);
-  }
-  removeSubgraph(subgraph) {
-    this.#objects.subgraphs.delete(subgraph);
-  }
-  createNode(id, attributes) {
-    const node = new this.#models.Node(id, attributes);
-    this.addNode(node);
-    return node;
-  }
-  getSubgraph(id) {
-    return Array.from(this.#objects.subgraphs.values()).find((subgraph) => subgraph.id === id);
-  }
-  getNode(id) {
-    return this.#objects.nodes.get(id);
-  }
-  createEdge(targets, attributes) {
-    const ts = targets.map((t) => (isNodeRefGroupLike(t) ? toNodeRefGroup(t) : toNodeRef(t)));
-    const edge = new this.#models.Edge(ts, attributes);
-    this.addEdge(edge);
-    return edge;
-  }
-  subgraph(...args) {
-    const id = args.find((arg) => typeof arg === 'string');
-    const attributes = args.find((arg) => typeof arg === 'object' && arg !== null);
-    const callback = args.find((arg) => typeof arg === 'function');
-    const subgraph = id ? this.getSubgraph(id) ?? this.createSubgraph(id) : this.createSubgraph();
-    if (attributes !== undefined) {
-      subgraph.apply(attributes);
-    }
-    if (callback !== undefined) {
-      callback(subgraph);
-    }
-    return subgraph;
-  }
-  node(firstArg, ...args) {
-    if (typeof firstArg === 'string') {
-      const id = firstArg;
-      const attributes = args.find((arg) => typeof arg === 'object' && arg !== null);
-      const callback = args.find((arg) => 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);
-    }
-  }
-  edge(firstArg, ...args) {
-    if (Array.isArray(firstArg)) {
-      const targets = firstArg;
-      const attributes = args.find((arg) => typeof arg === 'object');
-      const callback = args.find((arg) => 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);
-    }
-  }
-  graph(attributes) {
-    this.attributes.graph.apply(attributes);
-  }
-}
-
-class RootGraph extends GraphBase {
-  get $$type() {
-    return 'Graph';
-  }
-  id;
-  strict;
-  constructor(...args) {
-    super();
-    this.id = args.find((arg) => typeof arg === 'string');
-    this.strict = args.find((arg) => typeof arg === 'boolean') ?? false;
-    const attributes = args.find((arg) => typeof arg === 'object' && arg !== null);
-    if (attributes !== undefined) {
-      this.apply(attributes);
-    }
-  }
-}
-
-class Digraph extends RootGraph {
-  get directed() {
-    return true;
-  }
-}
-
-class Graph extends RootGraph {
-  get directed() {
-    return false;
-  }
-}
-
-class Subgraph extends GraphBase {
-  get $$type() {
-    return 'Subgraph';
-  }
-  id;
-  constructor(...args) {
-    super();
-    this.id = args.find((arg) => typeof arg === 'string');
-    const attributes = args.find((arg) => typeof arg === 'object' && arg !== null);
-    if (attributes !== undefined) {
-      this.apply(attributes);
-    }
-  }
-  isSubgraphCluster() {
-    if (typeof this.id === 'string') {
-      return this.id.startsWith('cluster');
-    }
-    return false;
-  }
-}
-
-class AttributesGroup extends AttributesBase {
-  comment;
-}
-
-class Node extends DotObject {
-  id;
-  get $$type() {
-    return 'Node';
-  }
-  comment;
-  attributes;
-  constructor(id, attributes) {
-    super();
-    this.id = id;
-    this.attributes = new AttributesGroup(attributes);
-  }
-  port(port) {
-    if (typeof port === 'string') {
-      return { id: this.id, port };
-    }
-    return { id: this.id, ...port };
-  }
-}
-
-class Edge extends DotObject {
-  targets;
-  get $$type() {
-    return 'Edge';
-  }
-  comment;
-  attributes;
-  constructor(targets, attributes) {
-    super();
-    this.targets = targets;
-    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);
-  }
-}
-
-Object.assign(RootModelsContext, {
-  Graph,
-  Digraph,
-  Subgraph,
-  Node,
-  Edge,
-});
-
-function ModelFactoryBuilder(directed, strictMode) {
-  return (...args) => {
-    const G = directed ? this.Digraph : this.Graph;
-    const id = args.find((arg) => typeof arg === 'string');
-    const attributes = args.find((arg) => typeof arg === 'object');
-    const callback = args.find((arg) => typeof arg === 'function');
-    const g = new G(id, strictMode, attributes);
-    g.with(this);
-    if (typeof callback === 'function') {
-      callback(g);
-    }
-    return g;
-  };
-}
-function createModelFactories(strict, context = RootModelsContext) {
-  return Object.freeze({
-    digraph: ModelFactoryBuilder.call(context, true, strict),
-    graph: ModelFactoryBuilder.call(context, false, strict),
-  });
-}
-
-const noStrict = createModelFactories(false);
-const digraph = noStrict.digraph;
-const graph = noStrict.graph;
-const strict = createModelFactories(true);
-function withContext(models) {
-  const context = createModelsContext(models);
-  return Object.freeze({
-    ...createModelFactories(false, context),
-    strict: createModelFactories(true, context),
-  });
-}
-
-function toDot(model, options) {
-  const ast = fromModel(model, options?.convert);
-  return stringify(ast, options?.print);
-}
-
-function fromDot(dot, options) {
-  const ast = parse(dot, options?.parse);
-  if (
-    Array.isArray(ast) ||
-    ast.type === 'Attribute' ||
-    ast.type === 'AttributeList' ||
-    ast.type === 'Comment' ||
-    ast.type === 'NodeRef' ||
-    ast.type === 'NodeRefGroup' ||
-    ast.type === 'Literal'
-  ) {
-    throw new Error();
-  }
-  return toModel(ast, options?.convert);
-}
-
-export {
-  AttributeList,
-  AttributesBase,
-  AttributesGroup,
-  Digraph,
-  DotObject,
-  Edge,
-  Graph,
-  GraphBase,
-  Node,
-  RootGraph,
-  Subgraph,
-  attribute,
-  digraph,
-  fromDot,
-  graph,
-  strict,
-  toDot,
-  withContext,
-};