feat: create sankey parser and integrate sankey parser into mermaid package

__mocks__/sankeyRenderer.ts

@@ -0,0 +1,8 @@
+/**
+ * Mocked Sankey diagram renderer
+ */
+import { vi } from 'vitest';
+
+export const draw = vi.fn().mockImplementation(() => undefined);
+
+export const renderer = { draw };

packages/mermaid/src/diagram-api/diagram-orchestration.ts

@@ -19,7 +19,7 @@ import errorDiagram from '../diagrams/error/errorDiagram.js';
 import flowchartElk from '../diagrams/flowchart/elk/detector.js';
 import timeline from '../diagrams/timeline/detector.js';
 import mindmap from '../diagrams/mindmap/detector.js';
-import sankey from '../diagrams/sankey/sankeyDetector.js';
+import { sankey } from '../diagrams/sankey/sankeyDetector.js';
 import { packet } from '../diagrams/packet/detector.js';
 import block from '../diagrams/block/blockDetector.js';
 import { registerLazyLoadedDiagrams } from './detectType.js';

packages/mermaid/src/diagrams/sankey/sankey.spec.ts

@@ -0,0 +1,25 @@
+import { parser } from './sankeyParser.js';
+import { db } from './sankeyDB.js';
+import * as fs from 'fs';
+import * as path from 'path';
+
+describe('sankey', () => {
+  beforeEach(() => db.clear());
+
+  it('should parse csv', async () => {
+    const csv = path.resolve(__dirname, './parser/energy.csv');
+    const data = fs.readFileSync(csv, 'utf8');
+    const graphDefinition = 'sankey-beta\n\n ' + data;
+
+    void parser.parse(graphDefinition);
+  });
+
+  it('allows __proto__ as id', async () => {
+    void parser.parse(
+      `sankey-beta
+      __proto__,A,0.597
+      A,__proto__,0.403
+      `
+    );
+  });
+});

packages/mermaid/src/diagrams/sankey/sankeyDB.ts

@@ -1,5 +1,3 @@
-import { getConfig } from '../../diagram-api/diagramAPI.js';
-import common from '../common/common.js';
 import {
   setAccTitle,
   getAccTitle,
@@ -9,79 +7,63 @@ import {
   getDiagramTitle,
   clear as commonClear,
 } from '../common/commonDb.js';
+import type { SankeyDiagramConfig } from '../../config.type.js';
+import type { SankeyDB, SankeyLink, SankeyFields } from './sankeyTypes.js';
+import DEFAULT_CONFIG from '../../defaultConfig.js';
+import type { RequiredDeep } from 'type-fest';
+
+export const DEFAULT_SANKEY_CONFIG: Required<SankeyDiagramConfig> = DEFAULT_CONFIG.sankey;
+
+export const DEFAULT_SANKEY_DB: RequiredDeep<SankeyFields> = {
+  links: [] as SankeyLink[],
+  nodes: [] as string[],
+  config: DEFAULT_SANKEY_CONFIG,
+} as const;
 
 // Sankey diagram represented by nodes and links between those nodes
-let links: SankeyLink[] = [];
+let links: SankeyLink[] = DEFAULT_SANKEY_DB.links;
 // Array of nodes guarantees their order
-let nodes: SankeyNode[] = [];
-// We also have to track nodes uniqueness (by ID)
-let nodesMap: Map<string, SankeyNode> = new Map();
+let nodes: string[] = DEFAULT_SANKEY_DB.nodes;
+const config: Required<SankeyDiagramConfig> = structuredClone(DEFAULT_SANKEY_CONFIG);
+
+const getConfig = (): Required<SankeyDiagramConfig> => structuredClone(config);
 
 const clear = (): void => {
   links = [];
   nodes = [];
-  nodesMap = new Map();
   commonClear();
 };
 
-class SankeyLink {
-  constructor(
-    public source: SankeyNode,
-    public target: SankeyNode,
-    public value: number = 0
-  ) {}
-}
-
 /**
  * @param source - Node where the link starts
  * @param target - Node where the link ends
  * @param value - Describes the amount to be passed
  */
-const addLink = (source: SankeyNode, target: SankeyNode, value: number): void => {
-  links.push(new SankeyLink(source, target, value));
+const addLink = ({ source, target, value }: SankeyLink): void => {
+  links.push({ source, target, value });
 };
 
-class SankeyNode {
-  constructor(public ID: string) {}
-}
-
-const findOrCreateNode = (ID: string): SankeyNode => {
-  ID = common.sanitizeText(ID, getConfig());
+const getLinks = (): SankeyLink[] => links;
 
-  let node = nodesMap.get(ID);
-  if (node === undefined) {
-    node = new SankeyNode(ID);
-    nodesMap.set(ID, node);
-    nodes.push(node);
-  }
-  return node;
+const addNode = (node: string): void => {
+  nodes.push(node);
 };
 
-const getNodes = () => nodes;
-const getLinks = () => links;
+const getNodes = (): string[] => nodes;
 
-const getGraph = () => ({
-  nodes: nodes.map((node) => ({ id: node.ID })),
-  links: links.map((link) => ({
-    source: link.source.ID,
-    target: link.target.ID,
-    value: link.value,
-  })),
-});
+export const db: SankeyDB = {
+  getConfig,
+  clear,
 
-export default {
-  nodesMap,
-  getConfig: () => getConfig().sankey,
-  getNodes,
-  getLinks,
-  getGraph,
-  addLink,
-  findOrCreateNode,
-  getAccTitle,
+  setDiagramTitle,
+  getDiagramTitle,
   setAccTitle,
-  getAccDescription,
+  getAccTitle,
   setAccDescription,
-  getDiagramTitle,
-  setDiagramTitle,
-  clear,
+  getAccDescription,
+
+  addLink,
+  addNode,
+  getLinks,
+  getNodes,
 };

packages/mermaid/src/diagrams/sankey/sankeyDetector.ts

@@ -1,20 +1,22 @@
-import type { DiagramDetector, ExternalDiagramDefinition } from '../../diagram-api/types.js';
+import type {
+  DiagramDetector,
+  DiagramLoader,
+  ExternalDiagramDefinition,
+} from '../../diagram-api/types.js';
 
 const id = 'sankey';
 
 const detector: DiagramDetector = (txt) => {
   return /^\s*sankey-beta/.test(txt);
 };
 
-const loader = async () => {
+const loader: DiagramLoader = async () => {
   const { diagram } = await import('./sankeyDiagram.js');
   return { id, diagram };
 };
 
-const plugin: ExternalDiagramDefinition = {
+export const sankey: ExternalDiagramDefinition = {
   id,
   detector,
   loader,
 };
-
-export default plugin;

packages/mermaid/src/diagrams/sankey/sankeyDiagram.ts

@@ -1,12 +1,7 @@
 import type { DiagramDefinition } from '../../diagram-api/types.js';
-// @ts-ignore: jison doesn't export types
-import parser from './parser/sankey.jison';
-import db from './sankeyDB.js';
-import renderer from './sankeyRenderer.js';
-import { prepareTextForParsing } from './sankeyUtils.js';
-
-const originalParse = parser.parse.bind(parser);
-parser.parse = (text: string) => originalParse(prepareTextForParsing(text));
+import { parser } from './sankeyParser.js';
+import { db } from './sankeyDB.js';
+import { renderer } from './sankeyRenderer.js';
 
 export const diagram: DiagramDefinition = {
   parser,

packages/mermaid/src/diagrams/sankey/sankeyParser.ts

@@ -0,0 +1,26 @@
+import type { Sankey, SankeyLink } from '@mermaid-js/parser';
+import { parse } from '@mermaid-js/parser';
+
+import { log } from '../../logger.js';
+import type { ParserDefinition } from '../../diagram-api/types.js';
+import { populateCommonDb } from '../common/populateCommonDb.js';
+import type { SankeyDB } from './sankeyTypes.js';
+import { db } from './sankeyDB.js';
+
+function populateDb(ast: Sankey, db: SankeyDB) {
+  populateCommonDb(ast, db);
+  ast.links.forEach((link: SankeyLink) => {
+    db.addLink(link);
+  });
+  ast.nodes.forEach((node: string) => {
+    db.addNode(node);
+  });
+}
+
+export const parser: ParserDefinition = {
+  parse: async (input: string): Promise<void> => {
+    const ast: Sankey = await parse('sankey', input);
+    log.debug(ast);
+    populateDb(ast, db);
+  },
+};