@zombie-mermaid/mermaid-parser 3.1.0 → 3.2.0

package/src/__tests__/c4-upstream-parser.test.ts

@@ -0,0 +1,340 @@
+import { describe, it, expect } from 'vitest'
+import { splitStatements } from '@zombie-mermaid/core'
+import { parseC4Diagram } from '../index.ts'
+
+// Fixtures ported from lukilabs/beautiful-mermaid#71 (c4-parser.test.ts) by
+// Victor Palma (devx), (MIT-licensed), adapted to this
+// fork's `parseC4Diagram` model (lowercase `variant`/`kind`, `shape`,
+// `children`/`elementAliases`). Assertions this design cannot satisfy are kept
+// as `it.skip` with the reason, so the gap stays visible.
+
+const parse = (src: string) => parseC4Diagram(splitStatements(src))
+
+describe('upstream #71: diagram types', () => {
+  it.each([
+    ['C4Context', 'context'],
+    ['C4Container', 'container'],
+    ['C4Component', 'component'],
+    ['C4Dynamic', 'dynamic'],
+  ] as const)('parses %s as variant %s', (header, variant) => {
+    const d = parse(`${header}\n  Person(user, "User", "A user")`)
+    expect(d.variant).toBe(variant)
+  })
+
+  it('parses C4Deployment with an empty Deployment_Node block', () => {
+    const d = parse(`C4Deployment
+  Deployment_Node(aws, "AWS", "Cloud") {
+  }`)
+    expect(d.variant).toBe('deployment')
+    expect(d.boundaries[0]).toMatchObject({ alias: 'aws', type: 'Cloud' })
+  })
+
+  // Upstream defaults an unknown header to C4Context; here it is an error.
+  it('rejects an unknown header instead of defaulting to C4Context', () => {
+    expect(() =>
+      parse('UnknownDiagram\n  Person(user, "User", "A user")'),
+    ).toThrow(/expected a header of C4Context/)
+  })
+})
+
+describe('upstream #71: element declarations', () => {
+  it('parses Person with alias, label, description', () => {
+    const d = parse(`C4Context
+  Person(user, "User", "A person who uses the system")`)
+    expect(d.elements).toHaveLength(1)
+    expect(d.elements[0]).toMatchObject({
+      kind: 'person',
+      alias: 'user',
+      label: 'User',
+      description: 'A person who uses the system',
+      external: false,
+    })
+  })
+
+  it('parses Person_Ext as external', () => {
+    const d = parse('C4Context\n  Person_Ext(admin, "Admin", "External admin")')
+    expect(d.elements[0]).toMatchObject({ kind: 'person', external: true })
+  })
+
+  it('parses System with alias and label only', () => {
+    const d = parse('C4Context\n  System(sys, "My System")')
+    expect(d.elements[0]).toMatchObject({
+      kind: 'system',
+      alias: 'sys',
+      label: 'My System',
+    })
+    expect(d.elements[0]!.description).toBeUndefined()
+  })
+
+  it('parses System_Ext as external', () => {
+    const d = parse(
+      'C4Context\n  System_Ext(ext, "External System", "Third party")',
+    )
+    expect(d.elements[0]).toMatchObject({
+      external: true,
+      label: 'External System',
+    })
+  })
+
+  it.each([
+    [
+      'Container(web, "Web App", "Java/Spring", "Serves web pages")',
+      'container',
+      'default',
+      'Java/Spring',
+    ],
+    [
+      'ContainerDb(db, "Database", "PostgreSQL", "Stores data")',
+      'container',
+      'db',
+      'PostgreSQL',
+    ],
+    [
+      'ContainerQueue(q, "Message Queue", "RabbitMQ", "Async")',
+      'container',
+      'queue',
+      'RabbitMQ',
+    ],
+    [
+      'Component(ctrl, "Controller", "Spring MVC", "Handles HTTP")',
+      'component',
+      'default',
+      'Spring MVC',
+    ],
+    [
+      'ComponentDb(repo, "Repository", "JPA", "Data access")',
+      'component',
+      'db',
+      'JPA',
+    ],
+    [
+      'ComponentQueue(h, "Event Handler", "Spring AMQP", "Events")',
+      'component',
+      'queue',
+      'Spring AMQP',
+    ],
+  ] as const)('parses %s with technology', (line, kind, shape, technology) => {
+    const d = parse(`C4Container\n  ${line}`)
+    expect(d.elements[0]).toMatchObject({ kind, shape, technology })
+  })
+
+  it('parses _Ext variants for Container types', () => {
+    const d = parse(
+      'C4Container\n  Container_Ext(ext, "External API", "REST", "Third party")',
+    )
+    expect(d.elements[0]).toMatchObject({ kind: 'container', external: true })
+  })
+
+  it('parses multiple elements', () => {
+    const d = parse(`C4Context
+  Person(user, "User", "End user")
+  System(sys, "System", "Main system")
+  System_Ext(ext, "Email", "Sends emails")`)
+    expect(d.elements).toHaveLength(3)
+  })
+})
+
+describe('upstream #71: title', () => {
+  it('parses a title directive', () => {
+    const d = parse(`C4Context
+  title System Context Diagram
+  Person(user, "User", "End user")`)
+    expect(d.title).toBe('System Context Diagram')
+  })
+
+  it('parses a quoted title', () => {
+    const d = parse(`C4Context
+  title "My C4 Diagram"
+  Person(user, "User", "End user")`)
+    expect(d.title).toBe('My C4 Diagram')
+  })
+
+  it('has no title when not specified', () => {
+    const d = parse('C4Context\n  Person(user, "User", "End user")')
+    expect(d.title).toBeUndefined()
+  })
+})
+
+describe('upstream #71: boundaries', () => {
+  it('parses System_Boundary with child elements', () => {
+    const d = parse(`C4Context
+  System_Boundary(sb, "System Boundary") {
+    Container(web, "Web App", "Java", "Serves pages")
+  }`)
+    expect(d.boundaries).toHaveLength(1)
+    expect(d.boundaries[0]).toMatchObject({
+      alias: 'sb',
+      label: 'System Boundary',
+      elementAliases: ['web'],
+    })
+  })
+
+  it.each(['Container_Boundary', 'Enterprise_Boundary', 'Boundary'])(
+    'parses %s',
+    (macro) => {
+      const d = parse(`C4Context
+  ${macro}(b, "Label") {
+    System(sys, "Internal System", "Core system")
+  }`)
+      expect(d.boundaries[0]).toMatchObject({ alias: 'b', label: 'Label' })
+    },
+  )
+
+  it('parses Deployment_Node as a boundary', () => {
+    const d = parse(`C4Deployment
+  Deployment_Node(aws, "AWS") {
+    Container(web, "Web App", "Docker", "Runs in container")
+  }`)
+    expect(d.boundaries[0]).toMatchObject({
+      alias: 'aws',
+      elementAliases: ['web'],
+    })
+  })
+
+  it('parses nested boundaries', () => {
+    const d = parse(`C4Context
+  Enterprise_Boundary(eb, "Enterprise") {
+    System_Boundary(sb, "System") {
+      Container(web, "Web App", "Java", "Serves pages")
+    }
+  }`)
+    expect(d.boundaries).toHaveLength(1)
+    expect(d.boundaries[0]!.children).toHaveLength(1)
+    expect(d.boundaries[0]!.children[0]!.elementAliases).toEqual(['web'])
+  })
+
+  it('places an element in its innermost boundary only', () => {
+    const d = parse(`C4Context
+  Enterprise_Boundary(eb, "Enterprise") {
+    System_Boundary(sb, "System") {
+      Container(web, "Web", "Java", "App")
+    }
+  }`)
+    expect(d.boundaries[0]!.elementAliases).toEqual([])
+    expect(d.boundaries[0]!.children[0]!.alias).toBe('sb')
+    expect(d.boundaries[0]!.children[0]!.elementAliases).toEqual(['web'])
+  })
+
+  // Known gap: the model keeps no boundary macro kind and no parent pointers;
+  // nesting is expressed through `children` / `elementAliases` instead.
+  it.skip('records the boundary macro kind (System_Boundary, Enterprise_Boundary, ...)', () => {
+    const d = parse(`C4Context
+  System_Boundary(sb, "S") {
+    System(s, "S")
+  }`)
+    expect(d.boundaries[0]).toMatchObject({ kind: 'System_Boundary' })
+  })
+
+  it.skip('sets parentBoundary on nested elements and child boundaries', () => {
+    const d = parse(`C4Context
+  System_Boundary(sb, "System") {
+    Container(web, "Web App", "Java", "Serves pages")
+  }`)
+    expect(d.elements.find((e) => e.alias === 'web')).toMatchObject({
+      parentBoundary: 'sb',
+    })
+  })
+})
+
+describe('upstream #71: relationships', () => {
+  const two = 'System(a, "A", "System A")\n  System(b, "B", "System B")'
+
+  it('parses Rel with from, to, label', () => {
+    const d = parse(`C4Context\n  ${two}\n  Rel(a, b, "Uses")`)
+    expect(d.relationships).toHaveLength(1)
+    expect(d.relationships[0]).toMatchObject({
+      from: 'a',
+      to: 'b',
+      label: 'Uses',
+    })
+  })
+
+  it('parses Rel with technology', () => {
+    const d = parse(
+      `C4Context\n  ${two}\n  Rel(a, b, "Makes API calls", "JSON/HTTPS")`,
+    )
+    expect(d.relationships[0]!.technology).toBe('JSON/HTTPS')
+  })
+
+  it.each(['Rel_D', 'Rel_U', 'Rel_L', 'Rel_R'])(
+    'accepts the %s layout-hint macro as a plain relationship',
+    (macro) => {
+      const d = parse(`C4Context\n  ${two}\n  ${macro}(a, b, "Calls")`)
+      expect(d.relationships).toHaveLength(1)
+      expect(d.relationships[0]).toMatchObject({ from: 'a', to: 'b' })
+    },
+  )
+
+  // Known gap: the direction hint is accepted and dropped; the flowchart
+  // pipeline lays out by rank, so there is nothing to record it for.
+  it.skip('records Rel_U/D/L/R direction hints', () => {
+    const d = parse(`C4Context\n  ${two}\n  Rel_D(a, b, "Uses")`)
+    expect(d.relationships[0]).toMatchObject({ direction: 'D' })
+  })
+
+  it('parses Rel_Back keeping the declared endpoints, flagged reversed', () => {
+    const d = parse(`C4Context\n  ${two}\n  Rel_Back(a, b, "Returns")`)
+    expect(d.relationships[0]).toMatchObject({
+      from: 'a',
+      to: 'b',
+      reversed: true,
+    })
+  })
+
+  it('parses BiRel as one bidirectional relationship', () => {
+    const d = parse(`C4Context\n  ${two}\n  BiRel(a, b, "Exchanges data")`)
+    expect(d.relationships).toHaveLength(1)
+    expect(d.relationships[0]).toMatchObject({
+      from: 'a',
+      to: 'b',
+      label: 'Exchanges data',
+      bidirectional: true,
+    })
+  })
+
+  it('parses multiple relationships', () => {
+    const d = parse(`C4Context
+  Person(user, "User", "End user")
+  System(web, "Web", "Frontend")
+  System(api, "API", "Backend")
+  Rel(user, web, "Visits")
+  Rel(web, api, "Calls")
+  Rel(api, web, "Returns data")`)
+    expect(d.relationships).toHaveLength(3)
+  })
+})
+
+describe('upstream #71: full diagrams', () => {
+  it('parses a complete C4 context diagram', () => {
+    const d = parse(`C4Context
+  title System Context Diagram
+  Person(customer, "Customer", "A customer of the bank")
+  System(banking, "Internet Banking System", "Allows customers to manage accounts")
+  System_Ext(email, "E-mail System", "Sends emails")
+  System_Ext(mainframe, "Mainframe Banking System", "Stores account info")
+  Rel(customer, banking, "Views account balances", "HTTPS")
+  Rel(banking, email, "Sends emails using", "SMTP")
+  Rel(banking, mainframe, "Gets account info from", "XML/HTTPS")`)
+    expect(d.variant).toBe('context')
+    expect(d.title).toBe('System Context Diagram')
+    expect(d.elements).toHaveLength(4)
+    expect(d.relationships).toHaveLength(3)
+    expect(d.elements.find((e) => e.alias === 'customer')!.kind).toBe('person')
+    expect(d.elements.find((e) => e.alias === 'email')!.external).toBe(true)
+  })
+
+  it('parses a C4 container diagram with boundaries', () => {
+    const d = parse(`C4Container
+  Person(user, "User", "End user")
+  System_Boundary(sb, "Internet Banking System") {
+    Container(web, "Web Application", "Java/Spring", "Delivers content")
+    ContainerDb(db, "Database", "PostgreSQL", "Stores user data")
+  }
+  Rel(user, web, "Visits", "HTTPS")
+  Rel(web, db, "Reads/writes", "JDBC")`)
+    expect(d.elements).toHaveLength(3)
+    expect(d.boundaries).toHaveLength(1)
+    expect(d.boundaries[0]!.elementAliases).toHaveLength(2)
+    expect(d.relationships).toHaveLength(2)
+  })
+})

package/src/architecture/parser.ts

@@ -0,0 +1,187 @@
+import { normalizeBrTags, type Statement } from '@zombie-mermaid/core'
+import type {
+  ArchitectureDiagram,
+  ArchitectureEdge,
+  ArchitecturePort,
+} from './types.ts'
+
+// ============================================================================
+// Architecture diagram parser
+//
+// Parses Mermaid's `architecture-beta` diagram
+// (https://mermaid.ai/open-source/syntax/architecture.html):
+//
+//   architecture-beta
+//     group api(cloud)[API]
+//     service db(database)[Database] in api
+//     service server(server)[Server] in api
+//     junction j1 in api
+//     db:L -- R:server
+//     server{group}:B --> T:client{group}
+//
+// Grammar:
+//   group    <id>[(icon)][[Title]] [in <parent>]
+//   service  <id>[(icon)][[Title]] [in <parent>]
+//   junction <id> [in <parent>]
+//   <id>[{group}]:<L|R|T|B> <--|-->|<-->|--> <L|R|T|B>:<id>[{group}]
+//   align row|column <id> <id> ...     (accepted, no effect: see to-graph)
+//
+// Unlike Mermaid's own parser, every malformed statement throws with its line
+// number rather than being dropped.
+// ============================================================================
+
+const ID = String.raw`[\w-]+`
+const DECL_RE = new RegExp(
+  String.raw`^(group|service)\s+(${ID})\s*(?:\(([^)]*)\))?\s*(?:\[([^\]]*)\])?(?:\s+in\s+(${ID}))?$`,
+)
+const JUNCTION_RE = new RegExp(
+  String.raw`^junction\s+(${ID})(?:\s+in\s+(${ID}))?$`,
+)
+const EDGE_RE = new RegExp(
+  String.raw`^(${ID})(\{group\})?:([LRTB])\s+(<)?--(>)?\s+([LRTB]):(${ID})(\{group\})?$`,
+)
+const ALIGN_RE = new RegExp(
+  String.raw`^align\s+(?:row|column)\s+${ID}(?:\s+${ID})+$`,
+)
+
+type Kind = 'group' | 'service' | 'junction'
+
+function fail(stmt: Statement, msg: string): never {
+  throw new Error(
+    `Architecture diagram, line ${stmt.line}: ${msg} — "${stmt.text}"`,
+  )
+}
+
+/** Strip the optional quotes around a custom icon name like `"logos:aws"`. */
+function cleanIcon(raw: string | undefined): string | undefined {
+  const icon = raw?.trim().replace(/^"(.*)"$/, '$1')
+  return icon || undefined
+}
+
+/**
+ * Parse a Mermaid architecture diagram.
+ * Expects the first statement to be the `architecture-beta` header.
+ */
+export function parseArchitecture(lines: Statement[]): ArchitectureDiagram {
+  const diagram: ArchitectureDiagram = {
+    groups: [],
+    services: [],
+    junctions: [],
+    edges: [],
+  }
+  const kinds = new Map<string, Kind>()
+  // `in` may name a group declared later, so parents and edge endpoints are
+  // resolved after the loop.
+  const parentRefs: { stmt: Statement; parent: string }[] = []
+  const pendingEdges: { stmt: Statement; edge: ArchitectureEdge }[] = []
+
+  const declare = (
+    stmt: Statement,
+    id: string,
+    kind: Kind,
+    parent: string | undefined,
+  ): void => {
+    if (kinds.has(id)) fail(stmt, `duplicate id "${id}"`)
+    if (parent === id) fail(stmt, `"${id}" cannot be inside itself`)
+    kinds.set(id, kind)
+    if (parent) parentRefs.push({ stmt, parent })
+  }
+
+  for (let i = 1; i < lines.length; i++) {
+    const stmt = lines[i]!
+    const text = stmt.text
+
+    const decl = text.match(DECL_RE)
+    if (decl) {
+      const kind = decl[1] as 'group' | 'service'
+      const id = decl[2]!
+      const title = decl[4]
+      const parent = decl[5]
+      declare(stmt, id, kind, parent)
+      const entry = {
+        id,
+        icon: cleanIcon(decl[3]),
+        title: title !== undefined ? normalizeBrTags(title.trim()) : id,
+        parent,
+      }
+      if (kind === 'group') diagram.groups.push(entry)
+      else diagram.services.push(entry)
+      continue
+    }
+
+    const junction = text.match(JUNCTION_RE)
+    if (junction) {
+      const id = junction[1]!
+      const parent = junction[2]
+      declare(stmt, id, 'junction', parent)
+      diagram.junctions.push({ id, parent })
+      continue
+    }
+
+    const edge = text.match(EDGE_RE)
+    if (edge) {
+      pendingEdges.push({
+        stmt,
+        edge: {
+          source: edge[1]!,
+          sourceGroup: edge[2] !== undefined,
+          sourcePort: edge[3] as ArchitecturePort,
+          arrowStart: edge[4] !== undefined,
+          arrowEnd: edge[5] !== undefined,
+          targetPort: edge[6] as ArchitecturePort,
+          target: edge[7]!,
+          targetGroup: edge[8] !== undefined,
+        },
+      })
+      continue
+    }
+
+    // Alignment constraints (Mermaid v11.16+) have no flowchart equivalent.
+    if (ALIGN_RE.test(text)) continue
+
+    fail(stmt, 'unrecognized statement')
+  }
+
+  for (const { stmt, parent } of parentRefs) {
+    if (kinds.get(parent) !== 'group') {
+      fail(stmt, `"in ${parent}" must name a declared group`)
+    }
+  }
+
+  const parentOf = new Map<string, string>()
+  for (const g of diagram.groups) if (g.parent) parentOf.set(g.id, g.parent)
+  for (const g of diagram.groups) {
+    const seen = new Set([g.id])
+    for (let p = parentOf.get(g.id); p; p = parentOf.get(p)) {
+      if (seen.has(p)) {
+        throw new Error(
+          `Architecture diagram: group "${g.id}" is nested inside itself`,
+        )
+      }
+      seen.add(p)
+    }
+  }
+
+  for (const { stmt, edge } of pendingEdges) {
+    const ends: [string, boolean][] = [
+      [edge.source, edge.sourceGroup],
+      [edge.target, edge.targetGroup],
+    ]
+    for (const [id, viaGroup] of ends) {
+      const kind = kinds.get(id)
+      if (!kind) fail(stmt, `unknown id "${id}"`)
+      if (kind === 'group') {
+        fail(stmt, `edges connect services or junctions, not the group "${id}"`)
+      }
+      const parent = [...diagram.services, ...diagram.junctions].find(
+        (n) => n.id === id,
+      )?.parent
+      if (viaGroup && !parent) {
+        fail(stmt, `"{group}" needs "${id}" to be declared inside a group`)
+      }
+    }
+    diagram.edges.push(edge)
+  }
+
+  return diagram
+}

package/src/architecture/to-graph.ts

@@ -0,0 +1,141 @@
+import type {
+  Direction,
+  MermaidEdge,
+  MermaidGraph,
+  MermaidNode,
+  MermaidSubgraph,
+  NodeShape,
+} from '@zombie-mermaid/core'
+import type {
+  ArchitectureDiagram,
+  ArchitectureEdge,
+  ArchitecturePort,
+} from './types.ts'
+
+// ============================================================================
+// Architecture -> flowchart lowering
+//
+// `architecture-beta` is boxes in nested boxes joined by edges, which the
+// flowchart pipeline already lays out and draws (ELK for SVG, the grid router
+// for ASCII). Like the other lowered types it becomes a `MermaidGraph`:
+//
+//   group          -> subgraph (nested via `in`)
+//   service        -> node; the icon picks a shape
+//   junction       -> small filled circle, no label
+//   edge           -> edge; `<`/`>` become arrowheads
+//   `{group}` end  -> the edge attaches to the service's enclosing group
+//
+// What is not carried over: Mermaid places services on a grid from the edge
+// ports, so `a:R -- L:b` means "b is right of a". Here ports only choose the
+// flow direction (majority axis) and which way each edge points in the
+// layout; exact placement is the flowchart layout's. Icons are not drawn
+// (only the database/disk shapes differ) and `align` is ignored.
+// ============================================================================
+
+/** Built-in Mermaid icons that have a distinct flowchart shape. */
+const ICON_SHAPE: Record<string, NodeShape> = {
+  database: 'cylinder',
+  disk: 'cylinder',
+  cloud: 'stadium',
+  internet: 'circle',
+}
+
+const HORIZONTAL: ReadonlySet<ArchitecturePort> = new Set(['L', 'R'])
+
+/** Flow direction: vertical only when more edges leave via T/B than L/R. */
+function pickDirection(edges: readonly ArchitectureEdge[]): Direction {
+  let horizontal = 0
+  let vertical = 0
+  for (const e of edges) {
+    for (const p of [e.sourcePort, e.targetPort]) {
+      if (HORIZONTAL.has(p)) horizontal++
+      else vertical++
+    }
+  }
+  return vertical > horizontal ? 'TB' : 'LR'
+}
+
+/**
+ * Whether the edge, as written, runs against the layout flow. `a:L -- R:b`
+ * puts `a` to the right of `b`, so in a left-to-right layout the edge has to
+ * be emitted reversed for `a` to land on the right.
+ */
+function runsBackwards(e: ArchitectureEdge, direction: Direction): boolean {
+  const horizontal = direction === 'LR' || direction === 'RL'
+  const [back, forward]: ArchitecturePort[] = horizontal
+    ? ['L', 'R']
+    : ['T', 'B']
+  // Source port on the far side of the flow, or target port on the near side.
+  if (e.sourcePort === forward || e.targetPort === back) return false
+  return e.sourcePort === back || e.targetPort === forward
+}
+
+export function architectureToGraph(
+  diagram: ArchitectureDiagram,
+): MermaidGraph {
+  const nodes = new Map<string, MermaidNode>()
+  const parentOf = new Map<string, string | undefined>()
+
+  for (const s of diagram.services) {
+    nodes.set(s.id, {
+      id: s.id,
+      label: s.title,
+      shape: (s.icon && ICON_SHAPE[s.icon]) || 'rectangle',
+    })
+    parentOf.set(s.id, s.parent)
+  }
+  for (const j of diagram.junctions) {
+    nodes.set(j.id, { id: j.id, label: '', shape: 'filled-circle' })
+    parentOf.set(j.id, j.parent)
+  }
+
+  // Subgraphs, nested. Children are attached in declaration order.
+  const subgraphs = new Map<string, MermaidSubgraph>()
+  for (const g of diagram.groups) {
+    subgraphs.set(g.id, {
+      id: g.id,
+      label: g.title,
+      nodeIds: [],
+      children: [],
+    })
+  }
+  const roots: MermaidSubgraph[] = []
+  for (const g of diagram.groups) {
+    const sg = subgraphs.get(g.id)!
+    const parent = g.parent ? subgraphs.get(g.parent) : undefined
+    if (parent) parent.children.push(sg)
+    else roots.push(sg)
+  }
+  for (const [id, parent] of parentOf) {
+    subgraphs.get(parent ?? '')?.nodeIds.push(id)
+  }
+
+  const direction = pickDirection(diagram.edges)
+  const edges: MermaidEdge[] = diagram.edges.map((e) => {
+    const end = (id: string, viaGroup: boolean): string =>
+      (viaGroup ? parentOf.get(id) : undefined) ?? id
+    const forward = !runsBackwards(e, direction)
+    const [source, target] = forward
+      ? [end(e.source, e.sourceGroup), end(e.target, e.targetGroup)]
+      : [end(e.target, e.targetGroup), end(e.source, e.sourceGroup)]
+    return {
+      source,
+      target,
+      style: 'solid',
+      hasArrowStart: forward ? e.arrowStart : e.arrowEnd,
+      hasArrowEnd: forward ? e.arrowEnd : e.arrowStart,
+    }
+  })
+
+  return {
+    direction,
+    nodes,
+    edges,
+    subgraphs: roots,
+    classDefs: new Map(),
+    classAssignments: new Map(),
+    nodeStyles: new Map(),
+    linkStyles: new Map(),
+    interactions: new Map(),
+  }
+}