ts-graphviz 1.0.1 → 1.2.0

package/lib/ast/index.cjs

@@ -59,7 +59,7 @@ const endOfLine = (eol) => {
   }
 };
 
-const AttributeListPrintPlugin$1 = {
+const AttributeListPrintPlugin = {
   match(ast) {
     return ast.type === 'AttributeList';
   },
@@ -253,8 +253,8 @@ const SubgraphPrintPlugin = {
   },
 };
 
-const defaultPlugins$1 = [
-  AttributeListPrintPlugin$1,
+const defaultPlugins$2 = [
+  AttributeListPrintPlugin,
   AttributePrintPlugin,
   CommentPrintPlugin,
   DotPrintPlugin,
@@ -273,7 +273,7 @@ const defaultPlugins$1 = [
 class Printer {
   options;
   /** @internal */
-  #plugins = [...defaultPlugins$1];
+  #plugins = [...defaultPlugins$2];
   constructor(options = {}) {
     this.options = options;
   }
@@ -5342,7 +5342,7 @@ function convertClusterChildren(context, model) {
   );
 }
 
-const AttributeListPrintPlugin = {
+const AttributeListPlugin = {
   match(model) {
     return model.$$type === 'AttributeList';
   },
@@ -5357,7 +5357,7 @@ const AttributeListPrintPlugin = {
   },
 };
 
-const EdgeConvertPlugin = {
+const EdgePlugin$1 = {
   match(model) {
     return model.$$type === 'Edge';
   },
@@ -5427,7 +5427,7 @@ const EdgeConvertPlugin = {
   },
 };
 
-const GraphConvertPlugin = {
+const GraphPlugin$1 = {
   match(model) {
     return model.$$type === 'Graph';
   },
@@ -5456,7 +5456,7 @@ const GraphConvertPlugin = {
   },
 };
 
-const NodeConvertPlugin = {
+const NodePlugin$1 = {
   match(model) {
     return model.$$type === 'Node';
   },
@@ -5481,7 +5481,7 @@ const NodeConvertPlugin = {
   },
 };
 
-const SubgraphConvertPlugin = {
+const SubgraphPlugin$1 = {
   match(model) {
     return model.$$type === 'Subgraph';
   },
@@ -5505,13 +5505,7 @@ const SubgraphConvertPlugin = {
   },
 };
 
-const defaultPlugins = [
-  AttributeListPrintPlugin,
-  EdgeConvertPlugin,
-  NodeConvertPlugin,
-  GraphConvertPlugin,
-  SubgraphConvertPlugin,
-];
+const defaultPlugins$1 = [AttributeListPlugin, EdgePlugin$1, NodePlugin$1, GraphPlugin$1, SubgraphPlugin$1];
 
 /**
  * @group Convert Model to AST
@@ -5519,7 +5513,7 @@ const defaultPlugins = [
 class FromModelConverter {
   options;
   /** @hidden */
-  #plugins = [...defaultPlugins];
+  #plugins = [...defaultPlugins$1];
   constructor(options = {}) {
     this.options = options;
   }
@@ -5530,7 +5524,6 @@ class FromModelConverter {
       commentKind,
       convert(m) {
         for (const plugin of plugins) {
-          /*  */
           if (plugin.match(m)) {
             return plugin.convert(context, m);
           }
@@ -5549,11 +5542,226 @@ function fromModel(model, options) {
   return new FromModelConverter(options).convert(model);
 }
 
+class CommentHolder {
+  comment = null;
+  set(comment) {
+    this.comment = comment;
+  }
+  reset() {
+    this.comment = null;
+  }
+  apply(model, location) {
+    if (location && this.comment?.location) {
+      if (this.comment?.kind === 'Block') {
+        if (this.comment.location.end.line === location.start.line - 1) {
+          model.comment = this.comment.value;
+        }
+      } else {
+        if (this.comment.location.end.line === location.start.line) {
+          model.comment = this.comment.value;
+        }
+      }
+    } else {
+      model.comment = this.comment?.value;
+    }
+    this.reset();
+  }
+}
+
+const DotPlugin = {
+  match(ast) {
+    return ast.type === 'Dot';
+  },
+  convert(context, ast) {
+    const commentHolder = new CommentHolder();
+    for (const stmt of ast.children) {
+      switch (stmt.type) {
+        case 'Comment':
+          commentHolder.set(stmt);
+          break;
+        case 'Graph':
+          const graph = context.convert(stmt);
+          commentHolder.apply(graph, stmt.location);
+          return graph;
+      }
+    }
+    throw Error();
+  },
+};
+
+function convertToEdgeTargetTuple(edge) {
+  return edge.targets.map((t) => {
+    switch (t.type) {
+      case 'NodeRef':
+        return { id: t.id.value, port: t.port?.value, compass: t.compass?.value };
+      case 'NodeRefGroup':
+        return t.children.map((t) => ({ id: t.id.value, port: t.port?.value, compass: t.compass?.value }));
+    }
+  });
+}
+
+const EdgePlugin = {
+  match(ast) {
+    return ast.type === 'Edge';
+  },
+  convert(context, ast) {
+    const edge = new context.models.Edge(
+      convertToEdgeTargetTuple(ast),
+      ast.children
+        .filter((v) => v.type === 'Attribute')
+        .reduce((prev, curr) => ({ ...prev, [curr.key.value]: curr.value.value }), {}),
+    );
+    return edge;
+  },
+};
+
+function applyStatements(graph, statements) {
+  const commentHolder = new CommentHolder();
+  for (const stmt of statements) {
+    switch (stmt.type) {
+      case 'Subgraph':
+        const subgraph = stmt.id ? graph.subgraph(stmt.id.value) : graph.subgraph();
+        applyStatements(subgraph, stmt.children);
+        commentHolder.apply(subgraph, stmt.location);
+        break;
+      case 'Attribute':
+        graph.set(stmt.key.value, stmt.value.value);
+        commentHolder.reset();
+        break;
+      case 'Node':
+        commentHolder.apply(
+          graph.node(
+            stmt.id.value,
+            stmt.children
+              .filter((v) => v.type === 'Attribute')
+              .reduce((prev, curr) => ({ ...prev, [curr.key.value]: curr.value.value }), {}),
+          ),
+          stmt.location,
+        );
+        break;
+      case 'Edge':
+        commentHolder.apply(
+          graph.edge(
+            convertToEdgeTargetTuple(stmt),
+            stmt.children
+              .filter((v) => v.type === 'Attribute')
+              .reduce((prev, curr) => ({ ...prev, [curr.key.value]: curr.value.value }), {}),
+          ),
+          stmt.location,
+        );
+        break;
+      case 'AttributeList':
+        const attrs = stmt.children
+          .filter((v) => v.type === 'Attribute')
+          .reduce((prev, curr) => ({ ...prev, [curr.key.value]: curr.value.value }), {});
+        switch (stmt.kind) {
+          case 'Edge':
+            graph.edge(attrs);
+            break;
+          case 'Node':
+            graph.node(attrs);
+            break;
+          case 'Graph':
+            graph.graph(attrs);
+            break;
+        }
+        commentHolder.reset();
+        break;
+      case 'Comment':
+        commentHolder.set(stmt);
+    }
+  }
+}
+
+const GraphPlugin = {
+  match(ast) {
+    return ast.type === 'Graph';
+  },
+  convert(context, ast) {
+    const G = ast.directed ? context.models.Digraph : context.models.Graph;
+    const graph = new G(ast.id?.value, ast.strict);
+    applyStatements(graph, ast.children);
+    return graph;
+  },
+};
+
+const SubgraphPlugin = {
+  match(ast) {
+    return ast.type === 'Subgraph';
+  },
+  convert(context, ast) {
+    const subgraph = new context.models.Subgraph(ast.id?.value);
+    applyStatements(subgraph, ast.children);
+    return subgraph;
+  },
+};
+
+const NodePlugin = {
+  match(ast) {
+    return ast.type === 'Node';
+  },
+  convert(context, ast) {
+    const node = new context.models.Node(
+      ast.id.value,
+      ast.children
+        .filter((v) => v.type === 'Attribute')
+        .reduce((prev, curr) => ({ ...prev, [curr.key.value]: curr.value.value }), {}),
+    );
+    return node;
+  },
+};
+
+const defaultPlugins = [NodePlugin, EdgePlugin, SubgraphPlugin, GraphPlugin, DotPlugin];
+
+/**
+ * @group Convert AST to Model
+ * @alpha
+ */
+class ToModelConverter {
+  options;
+  /** @hidden */
+  plugins = [...defaultPlugins];
+  constructor(options = {}) {
+    this.options = options;
+  }
+  /**
+   * Convert AST to Model.
+   *
+   * @param ast AST node.
+   * @alpha
+   */
+  convert(ast) {
+    const plugins = [...this.plugins];
+    const context = {
+      models: common.createModelsContext(this.options.models ?? {}),
+      convert(m) {
+        for (const plugin of plugins) {
+          if (plugin.match(m)) {
+            return plugin.convert(context, m);
+          }
+        }
+        throw Error();
+      },
+    };
+    return context.convert(ast);
+  }
+}
+
+/**
+ * @group Convert AST to Model
+ * @beta
+ */
+function toModel(ast, options) {
+  return new ToModelConverter(options).convert(ast);
+}
+
 exports.Builder = Builder;
 exports.FromModelConverter = FromModelConverter;
 exports.Printer = Printer;
 exports.SyntaxError = SyntaxError;
+exports.ToModelConverter = ToModelConverter;
 exports.createElement = createElement;
 exports.fromModel = fromModel;
 exports.parse = parse;
 exports.stringify = stringify;
+exports.toModel = toModel;

package/lib/ast/index.d.ts

@@ -1,4 +1,14 @@
-import { Compass, AttributeKey, ASTType, DotObjectType, DotObjectModel } from '#lib/common';
+import {
+  Compass,
+  AttributeKey,
+  ASTType,
+  DotObjectModel,
+  RootGraphModel,
+  EdgeModel,
+  NodeModel,
+  SubgraphModel,
+  ModelsContext,
+} from '#lib/common';
 
 /**
  * @group AST
@@ -432,6 +442,7 @@ declare function parse(input: string, options?: ParseOptions<'AttributeList'>):
 declare function parse(input: string, options?: ParseOptions<'Attribute'>): AttributeASTNode;
 declare function parse(input: string, options?: ParseOptions<'Subgraph'>): SubgraphASTNode;
 declare function parse(input: string, options?: ParseOptions<'ClusterStatements'>): ClusterStatementASTNode[];
+declare function parse(input: string, options?: ParseOptions<Rule>): ASTNode | ClusterStatementASTNode[];
 /**
  * @group Convert DOT to AST
  */
@@ -440,9 +451,7 @@ declare const SyntaxError: typeof SyntaxError$1;
 /**
  * @group AST
  */
-declare type ModelToAST<T> = T extends {
-  $$type: infer U extends DotObjectType;
-}
+declare type ModelToAST<T> = T extends DotObjectModel<infer U>
   ? U extends 'Graph'
     ? GraphASTNode | DotASTNode
     : U extends 'AttributeList'
@@ -493,6 +502,79 @@ declare class FromModelConverter {
  */
 declare function fromModel<T extends DotObjectModel>(model: T, options?: ConvertFromModelOptions): ModelToAST<T>;
 
+/**
+ * @group AST
+ */
+declare type ModelOf<T> = T extends 'Dot' | 'Graph'
+  ? RootGraphModel
+  : T extends 'Edge'
+  ? EdgeModel
+  : T extends 'Node'
+  ? NodeModel
+  : T extends 'Subgraph'
+  ? SubgraphModel
+  : never;
+/**
+ * @group AST
+ */
+declare type ASTToModel<T> = T extends {
+  type: infer U;
+}
+  ? ModelOf<U>
+  : never;
+/**
+ * @group Convert AST to Model
+ * @beta
+ */
+declare type ToModelConvertableASTNode = DotASTNode | GraphASTNode | SubgraphASTNode | NodeASTNode | EdgeASTNode;
+/**
+ * @group Convert AST to Model
+ * @alpha
+ */
+interface ConvertToModelOptions {
+  models?: Partial<ModelsContext>;
+}
+/**
+ * @group Convert AST to Model
+ * @alpha
+ */
+interface ConvertToModelContext {
+  models: ModelsContext;
+  convert<T extends ToModelConvertableASTNode>(ast: T): ASTToModel<T>;
+}
+/**
+ * @group Convert AST to Model
+ * @alpha
+ */
+interface ConvertToModelPlugin<T extends ToModelConvertableASTNode = ToModelConvertableASTNode> {
+  match(ast: T): boolean;
+  convert(context: ConvertToModelContext, ast: T): ASTToModel<T>;
+}
+
+/**
+ * @group Convert AST to Model
+ * @alpha
+ */
+declare class ToModelConverter {
+  private options;
+  /** @hidden */
+  protected plugins: ConvertToModelPlugin<ToModelConvertableASTNode>[];
+  constructor(options?: ConvertToModelOptions);
+  /**
+   * Convert AST to Model.
+   *
+   * @param ast AST node.
+   * @alpha
+   */
+  convert<T extends ToModelConvertableASTNode>(ast: T): ASTToModel<T>;
+}
+
+/**
+ * @group Convert AST to Model
+ * @beta
+ */
+declare function toModel<T extends ToModelConvertableASTNode>(ast: T, options?: ConvertToModelOptions): ASTToModel<T>;
+
 export {
   ASTBaseNode,
   ASTBaseParentNode,
@@ -500,6 +582,7 @@ export {
   ASTChildNode,
   ASTCommonPropaties,
   ASTNode,
+  ASTToModel,
   AttributeASTNode,
   AttributeASTPropaties,
   AttributeListASTNode,
@@ -514,6 +597,9 @@ export {
   ConvertFromModelContext,
   ConvertFromModelOptions,
   ConvertFromModelPlugin,
+  ConvertToModelContext,
+  ConvertToModelOptions,
+  ConvertToModelPlugin,
   CreateElement,
   DotASTNode,
   DotASTPropaties,
@@ -529,6 +615,7 @@ export {
   IndentStyle,
   LiteralASTNode,
   LiteralASTPropaties,
+  ModelOf,
   ModelToAST,
   NodeASTNode,
   NodeASTPropaties,
@@ -546,8 +633,11 @@ export {
   SubgraphASTNode,
   SubgraphASTPropaties,
   SyntaxError,
+  ToModelConvertableASTNode,
+  ToModelConverter,
   createElement,
   fromModel,
   parse,
   stringify,
+  toModel,
 };