@ts-graphviz/core 0.0.0-pr956-20240225073457

package/lib/core.d.ts

@@ -0,0 +1,323 @@
+import { Attribute } from '@ts-graphviz/common';
+import { AttributeKey } from '@ts-graphviz/common';
+import { AttributeListKind } from '@ts-graphviz/common';
+import { AttributeListModel } from '@ts-graphviz/common';
+import { Attributes } from '@ts-graphviz/common';
+import { AttributesEntities } from '@ts-graphviz/common';
+import { AttributesGroupModel } from '@ts-graphviz/common';
+import { AttributesObject } from '@ts-graphviz/common';
+import { ClusterSubgraphAttributeKey } from '@ts-graphviz/common';
+import { ConvertFromModelOptions } from '@ts-graphviz/ast';
+import { ConvertToModelOptions } from '@ts-graphviz/ast';
+import { DotObjectModel } from '@ts-graphviz/common';
+import { EdgeAttributeKey } from '@ts-graphviz/common';
+import { EdgeAttributesObject } from '@ts-graphviz/common';
+import { EdgeModel } from '@ts-graphviz/common';
+import { EdgeTargetLikeTuple } from '@ts-graphviz/common';
+import { EdgeTargetTuple } from '@ts-graphviz/common';
+import { ForwardRefNode } from '@ts-graphviz/common';
+import { GraphAttributeKey } from '@ts-graphviz/common';
+import { GraphAttributesObject } from '@ts-graphviz/common';
+import { GraphBaseModel } from '@ts-graphviz/common';
+import { GraphCommonAttributes } from '@ts-graphviz/common';
+import { ModelsContext } from '@ts-graphviz/common';
+import { NodeAttributeKey } from '@ts-graphviz/common';
+import { NodeAttributesObject } from '@ts-graphviz/common';
+import { NodeModel } from '@ts-graphviz/common';
+import { ParseOptions } from '@ts-graphviz/ast';
+import { Port } from '@ts-graphviz/common';
+import { PrintOptions } from '@ts-graphviz/ast';
+import { RootGraphModel } from '@ts-graphviz/common';
+import { SubgraphAttributeKey } from '@ts-graphviz/common';
+import { SubgraphAttributesObject } from '@ts-graphviz/common';
+import { SubgraphModel } from '@ts-graphviz/common';
+
+/**
+ * @group Attribute
+ */
+export declare const attribute: Attribute.keys;
+
+/**
+ * @group Attribute
+ *
+ * @deprecated Use {@link Attribute.keys} instead.
+ */
+export declare type AttributeKeyDict = Attribute.keys;
+
+/**
+ * A set of attribute values for any object.
+ * @group Models
+ */
+export 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>);
+}
+
+/**
+ * Base class for DOT objects with attributes.
+ * @group Models
+ */
+export 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
+ */
+export declare class AttributesGroup<T extends AttributeKey = AttributeKey> extends AttributesBase<T> implements AttributesGroupModel<T> {
+    comment?: string;
+}
+
+/**
+ * DOT object class representing a digraph.
+ * @group Models
+ */
+export declare class Digraph extends RootGraph {
+    get directed(): boolean;
+}
+
+/**
+ *  digraph is a factory for creating Digraph objects.
+ * @group Model Factory
+ */
+export declare const digraph: ModelFactory;
+
+/**
+ * Base class for DOT objects.
+ * @group Models
+ */
+export declare abstract class DotObject {
+}
+
+/**
+ * DOT object class representing a edge.
+ * @group Models
+ */
+export declare class Edge extends DotObject implements EdgeModel {
+    readonly targets: EdgeTargetTuple;
+    get $$type(): 'Edge';
+    comment?: string;
+    readonly attributes: AttributesGroupModel<EdgeAttributeKey>;
+    constructor(targets: EdgeTargetTuple, attributes?: EdgeAttributesObject);
+}
+
+/**
+ * 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.
+ */
+export declare function fromDot(dot: string, options?: FromDotOptions<'Dot' | 'Graph'>): RootGraphModel;
+
+export declare function fromDot(dot: string, options?: FromDotOptions<'Node'>): NodeModel;
+
+export declare function fromDot(dot: string, options?: FromDotOptions<'Edge'>): EdgeModel;
+
+export declare function fromDot(dot: string, options?: FromDotOptions<'Subgraph'>): SubgraphModel;
+
+/**
+ * This interface provides options for converting DOT to a model.
+ * @group Convert DOT to Model
+ */
+export declare 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;
+}
+
+/**
+ * DOT object class representing a graph.
+ * @group Models
+ */
+export declare class Graph extends RootGraph {
+    get directed(): boolean;
+}
+
+/**
+ * graph is a factory for creating Graph objects.
+ * @group Model Factory
+ */
+export declare const graph: ModelFactory;
+
+/**
+ * Base class for Graph objects.
+ * @group Models
+ */
+export 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;
+}
+
+/**
+ * @group Model Factory
+ */
+export declare interface ModelFactories {
+    /**
+     * API for creating directional graph objects.
+     */
+    digraph: ModelFactory;
+    /**
+     * API for creating omnidirectional graph objects.
+     */
+    graph: ModelFactory;
+}
+
+/**
+ * @group Model Factory
+ */
+export declare interface ModelFactoriesWithStrict extends ModelFactories {
+    strict: ModelFactories;
+}
+
+/**
+ * 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 declare 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;
+ }
+
+ /**
+  * DOT object class representing a node.
+  * @group Models
+  */
+ declare class Node_2 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;
+ }
+ export { Node_2 as Node }
+
+ /**
+  * Base class representing a root graph(digraph, graph).
+  * @group Models
+  */
+ export 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);
+ }
+
+ /**
+  * Provides a strict mode API.
+  * @group Model Factory
+  */
+ export declare const strict: ModelFactories;
+
+ /**
+  * DOT object class representing a subgraph.
+  * @group Models
+  */
+ export 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;
+ }
+
+ /**
+  * 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
+  */
+ export declare function toDot(model: DotObjectModel, options?: ToDotOptions): string;
+
+ /**
+  * This interface provides options for converting a model to DOT.
+  * @group Convert Model to DOT
+  */
+ export declare interface ToDotOptions {
+     /**
+      * Options for converting the model to DOT.
+      */
+     convert?: ConvertFromModelOptions;
+     /**
+      * Options for printing DOT.
+      */
+     print?: PrintOptions;
+ }
+
+ /**
+  * 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 declare function withContext(models: Partial<ModelsContext>): ModelFactoriesWithStrict;
+
+ export { }