structviz 0.2__py3-none-any.whl

structviz/generators/equity.py

@@ -0,0 +1,38 @@
+from typing import Optional
+from ..models import EquityChart
+from ..themes import THEMES, parse_paper_size
+
+def generate_equity_dot(chart: EquityChart, paper_size: Optional[str] = None, dpi: Optional[int] = None) -> str:
+    theme = THEMES.get(chart.meta.theme, THEMES["corporate"])
+    lines = ['digraph G {']
+    lines.append(f'label="{chart.meta.title}"; labelloc=t; fontsize=14;')
+    lines.append(f'rankdir=TB;')
+    ps = parse_paper_size(paper_size) if paper_size else None
+    if ps:
+        lines.append(f'size="{ps["size"]}"; ratio={ps["ratio"]}; margin=0;')
+        lines.append(f'ranksep=0.3; nodesep=0.15;')
+    else:
+        lines.append(f'ranksep={theme["ranksep"]}; nodesep={theme["nodesep"]};')
+    if dpi:
+        lines.append(f'dpi={dpi};')
+    nd = theme["node_default"]
+    lines.append(f'node [shape={nd["shape"]} fontname="{nd["fontname"]}" fontsize={nd["fontsize"]}];')
+    lines.append(f'edge [color="{theme["edge_color"]}" penwidth={theme["edge_penwidth"]}];')
+
+    for node in chart.nodes:
+        attrs = []
+        if node.shape: attrs.append(f'shape={node.shape}')
+        if node.style: attrs.append(f'style="{node.style}"')
+        if node.fillcolor: attrs.append(f'fillcolor="{node.fillcolor}"')
+        if node.color: attrs.append(f'color="{node.color}"')
+        if node.fontcolor: attrs.append(f'fontcolor="{node.fontcolor}"')
+        attr_str = ", ".join(attrs)
+        lines.append(f'"{node.id}" [label="{node.label}" {attr_str}];')
+
+    for edge in chart.edges:
+        attrs = [f'label="{edge.label}"', f'penwidth={edge.penwidth}',
+                 f'color="{edge.color}"', f'style={edge.style}']
+        lines.append(f'"{edge.from_id}" -> "{edge.to}" [{", ".join(attrs)}];')
+
+    lines.append('}')
+    return '\n'.join(lines)

structviz/generators/excalidraw.py

@@ -0,0 +1,281 @@
+"""Excalidraw generator. YAML model → .excalidraw JSON with manual layout."""
+import json, math
+from typing import Optional, List, Dict, Any
+from ..models import OrgChart, OrgNode, OrgBlock
+from ..themes import THEMES
+
+RECT = "rectangle"; TEXT = "text"; ARROW = "arrow"
+
+# Layout constants (Excalidraw units ≈ px)
+LARGE_W, LARGE_H = 120, 38
+CARD_W, CARD_H = 130, 48
+DEPT_W, DEPT_H = 110, 34
+SIDE_W, SIDE_H = 110, 34       # side block node (committee)
+GAP_Y = 60                      # inter-level vertical gap
+GAP_X = 16                      # inter-node horizontal gap
+ROW_GAP = 8                     # intra-block row gap
+PAD_X = 8; PAD_Y = 20           # block padding
+PAGE_W = 1600; PAGE_MARGIN = 40
+FONT = 13; FONT_S = 11
+
+def _tc(name):
+    t = THEMES.get(name, THEMES["corporate"])
+    return {"hb": t["card_header_bg"], "hf": t["card_header_font"],
+            "bb": t["card_body_bg"], "br": t["card_border_color"],
+            "db": t["dept_fillcolor"], "dc": t["dept_border"],
+            "cb": t["cluster_bg"], "ec": t["edge_color"]}
+
+def _el(eid, tp, x, y, w, h, **kw):
+    return {"id": eid, "type": tp, "x": round(x,1), "y": round(y,1),
+            "width": round(w,1), "height": round(h,1),
+            "strokeColor": kw.get("sc","#1e1e1e"),
+            "backgroundColor": kw.get("bg","#ffffff"),
+            "fillStyle": kw.get("fs","solid"),
+            "strokeWidth": kw.get("sw",1),
+            "strokeStyle": kw.get("ss","solid"),
+            "roughness": 0, "opacity": 100,
+            "roundness": {"type":3} if tp==RECT else None,
+            "groupIds": [], "isDeleted": False}
+
+def _tx(eid, x, y, w, h, text, fs=FONT, color="#1e1e1e", bold=False):
+    return {"id": eid, "type": TEXT, "x": round(x,1), "y": round(y,1),
+            "width": round(w,1), "height": round(h,1),
+            "text": text, "fontSize": fs, "fontFamily": 1,
+            "textAlign": "center", "verticalAlign": "middle",
+            "strokeColor": color, "backgroundColor": "transparent",
+            "fillStyle": "solid", "strokeWidth": 0, "roughness": 0,
+            "opacity": 100, "groupIds": [], "isDeleted": False}
+
+def _ar(eid, pts, sc="#7F8C8D"):
+    x0, y0 = pts[0]
+    return {"id": eid, "type": ARROW,
+            "x": round(x0,1), "y": round(y0,1), "width": 0, "height": 0,
+            "points": [[round(p[0]-x0,1), round(p[1]-y0,1)] for p in pts],
+            "startArrowhead": None, "endArrowhead": "arrow",
+            "strokeColor": sc, "strokeWidth": 2, "roughness": 0,
+            "opacity": 100, "groupIds": [], "isDeleted": False,
+            "startBinding": None, "endBinding": None}
+
+def generate_org_excalidraw(chart: OrgChart, paper_size=None, dpi=None):
+    tc = _tc(chart.meta.theme)
+    layout = chart.meta.layout
+    els = []; ei = [0]; nr = {}
+
+    def _nid(): ei[0]+=1; return f"e{ei[0]}"
+
+    def _large(node, x, y):
+        e = _el(_nid(), RECT, x, y, LARGE_W, LARGE_H, bg=tc["hb"], sc=tc["br"])
+        els.append(e); els.append(_tx(_nid(), x, y, LARGE_W, LARGE_H,
+                                      node.title, FONT+2, "#ffffff", True))
+        return {"eid": e["id"], "x": x, "y": y, "w": LARGE_W, "h": LARGE_H}
+
+    def _card(node, x, y):
+        w = CARD_W; h = CARD_H
+        lines = max(1, node.title.count('\n') + 1)
+        h = 22 + lines * 16
+        e = _el(_nid(), RECT, x, y, w, h, bg=tc["bb"], sc=tc["br"])
+        els.append(e)
+        els.append(_el(_nid(), RECT, x, y, w, 20, bg=tc["hb"], sc=tc["hb"]))
+        title = node.title.replace('\n', ' ')
+        els.append(_tx(_nid(), x, y+1, w, 18, title, FONT, tc["hf"], True))
+        return {"eid": e["id"], "x": x, "y": y, "w": w, "h": h}
+
+    def _side(node, x, y):
+        e = _el(_nid(), RECT, x, y, SIDE_W, SIDE_H, bg=tc["hb"], sc=tc["br"])
+        els.append(e)
+        els.append(_tx(_nid(), x, y, SIDE_W, SIDE_H, node.title, FONT_S, "#ffffff"))
+        return {"eid": e["id"], "x": x, "y": y, "w": SIDE_W, "h": SIDE_H}
+
+    def _dept(node, x, y):
+        e = _el(_nid(), RECT, x, y, DEPT_W, DEPT_H, bg=tc["db"], sc=tc["dc"])
+        els.append(e)
+        els.append(_tx(_nid(), x, y, DEPT_W, DEPT_H, node.title, FONT_S, "#1e1e1e"))
+        return {"eid": e["id"], "x": x, "y": y, "w": DEPT_W, "h": DEPT_H}
+
+    def _chunk_layout(nodes, start_x, y, node_w, node_h, gap_x, max_cols, render_fn):
+        """Layout nodes in max_cols per row. Returns list of (x,y,info) and total_h."""
+        rows = [nodes[i:i+max_cols] for i in range(0, len(nodes), max_cols)]
+        results = []
+        for row in rows:
+            rw = len(row) * (node_w + gap_x) - gap_x
+            rx = start_x + (max_cols * (node_w + gap_x) - gap_x - rw) / 2
+            for j, n in enumerate(row):
+                info = render_fn(n, rx + j * (node_w + gap_x), y)
+                results.append(info)
+            y += node_h + ROW_GAP
+        return results, y
+
+    cur_y = PAGE_MARGIN
+
+    for group in chart.groups:
+        right_blocks = [b for b in group.blocks if b.position == "right"]
+        bottom_blocks = [b for b in group.blocks if b.position == "bottom"]
+        main_nodes = group.nodes
+        right_nodes = group.right_nodes
+
+        # Level starting Y
+        level_start_y = cur_y
+        if getattr(group, 'gap', None):
+            cur_y += group.gap * 15
+
+        # ── Collect ALL same-rank nodes (main + right_nodes + side block nodes) ──
+        all_same = list(main_nodes) + list(right_nodes)
+        for b in right_blocks:
+            all_same.extend(b.nodes)
+
+        # Determine if we need multi-row for side block wrapping
+        side_mc = right_blocks[0].max_columns if right_blocks else 0
+        side_wrap = side_mc > 0 and len([n for b in right_blocks for n in b.nodes]) > side_mc
+
+        if side_wrap:
+            # Layout: main node on left, side block nodes to the right, wrapped
+            total_nodes = len(main_nodes) + len(right_nodes)
+            total_side = len([n for b in right_blocks for n in b.nodes])
+            side_chunks = [[n for b in right_blocks for n in b.nodes][i:i+side_mc]
+                          for i in range(0, total_side, side_mc)]
+
+            # Center the combined content
+            main_w = len(main_nodes) * (LARGE_W + GAP_X) - GAP_X if main_nodes else 0
+            side_total_w = side_mc * (SIDE_W + GAP_X)
+            total_w = main_w + GAP_X * 3 + side_total_w
+            start_x = (PAGE_W - total_w) / 2
+
+            # Main nodes at left
+            m_cur_y = cur_y
+            for i, node in enumerate(main_nodes):
+                x = start_x + i * (LARGE_W + GAP_X)
+                nr[node.id] = _large(node, x, m_cur_y)
+                m_cur_y = max(m_cur_y, cur_y)
+
+            # Side block nodes wrapping
+            s_cur_y = cur_y
+            side_info = []
+            side_x = start_x + main_w + GAP_X * 3
+            for chunk in side_chunks:
+                for j, node in enumerate(chunk):
+                    x = side_x + j * (SIDE_W + GAP_X)
+                    info = _card(node, x, s_cur_y)
+                    nr[node.id] = info
+                    side_info.append(info)
+                s_cur_y += SIDE_H + ROW_GAP
+
+            # Dashed block around side nodes
+            if side_info:
+                bx = min(i["x"] for i in side_info) - PAD_X
+                by = min(i["y"] for i in side_info) - PAD_Y
+                bw = max(i["x"] + i["w"] for i in side_info) - bx + PAD_X
+                bh = max(i["y"] + i["h"] for i in side_info) - by + PAD_Y
+                els.append(_el(_nid(), RECT, bx, by, bw, bh,
+                              bg=tc["cb"], sc=tc["br"], ss="dashed"))
+
+            cur_y = max(s_cur_y, cur_y + LARGE_H) + GAP_Y
+
+        else:
+            # Standard: all nodes on one row, centered
+            n_total = len(all_same) if all_same else 1
+            total_w = n_total * (LARGE_W + GAP_X) - GAP_X
+            start_x = (PAGE_W - total_w) / 2
+            if group.offset and group.offset > 0:
+                start_x += group.offset * 72
+
+            for i, node in enumerate(all_same):
+                x = start_x + i * (LARGE_W + GAP_X)
+                nr[node.id] = _large(node, x, cur_y) if node.style == "large" else _card(node, x, cur_y)
+
+            # Dashed block for right blocks (non-wrapping)
+            for b in right_blocks:
+                if not b.nodes: continue
+                xs = [nr[n.id]["x"] for n in b.nodes if n.id in nr]
+                if not xs: continue
+                bx = min(xs) - PAD_X
+                bw = max(nr[n.id]["x"] + nr[n.id]["w"] for n in b.nodes if n.id in nr) - bx + PAD_X
+                by = min(nr[n.id]["y"] for n in b.nodes if n.id in nr) - PAD_Y
+                bh = max(nr[n.id]["y"] + nr[n.id]["h"] for n in b.nodes if n.id in nr) - by + PAD_Y
+                els.append(_el(_nid(), RECT, bx, by, bw, bh,
+                              bg=tc["cb"], sc=tc["br"], ss="dashed"))
+
+            cur_y += LARGE_H + GAP_Y
+
+        # ── Bottom blocks ──
+        if bottom_blocks:
+            max_cols = group.max_columns or (layout.max_columns if layout else 3)
+            if max_cols <= 0: max_cols = len(bottom_blocks)
+            eff_cols = min(max_cols, len(bottom_blocks))
+
+            # Column width per block
+            col_w = DEPT_W * 2 + GAP_X  # max_columns=2 → two depts per row
+            total_block_w = eff_cols * col_w + (eff_cols - 1) * GAP_X * 2
+            block_start_x = (PAGE_W - total_block_w) / 2
+
+            max_block_h = 0
+            block_anchors = []
+
+            for bi, b in enumerate(bottom_blocks):
+                col = bi % eff_cols
+                bx = block_start_x + col * (col_w + GAP_X * 2)
+                dept_y = cur_y
+                block_info = []
+
+                depts = [n for n in b.nodes if not n.is_cluster_head]
+                heads = [n for n in b.nodes if n.is_cluster_head]
+                mc = b.max_columns or 2
+
+                # Heads
+                for h in heads:
+                    info = _large(h, bx + (col_w - LARGE_W)/2, dept_y)
+                    nr[h.id] = info; block_info.append(info)
+                    dept_y += LARGE_H + ROW_GAP
+
+                # Departments in rows
+                for ri in range(0, len(depts), mc):
+                    row = depts[ri:ri+mc]
+                    rw = len(row) * (DEPT_W + GAP_X) - GAP_X
+                    rx = bx + (col_w - rw) / 2
+                    for j, d in enumerate(row):
+                        info = _dept(d, rx + j * (DEPT_W + GAP_X), dept_y)
+                        nr[d.id] = info; block_info.append(info)
+                    dept_y += DEPT_H + ROW_GAP
+
+                # Dashed block rect
+                if block_info:
+                    minx = min(i["x"] for i in block_info) - PAD_X
+                    miny = min(i["y"] for i in block_info) - PAD_Y
+                    maxx = max(i["x"] + i["w"] for i in block_info) + PAD_X
+                    maxy = max(i["y"] + i["h"] for i in block_info) + PAD_Y
+                    els.append(_el(_nid(), RECT, minx, miny, maxx-minx, maxy-miny,
+                                  bg=tc["cb"], sc=tc["br"], ss="dashed"))
+                    block_anchors.append((minx, miny, maxx, maxy))
+                    max_block_h = max(max_block_h, maxy - cur_y)
+
+            cur_y += max_block_h + GAP_Y
+
+    # ── Arrows ──
+    for group in chart.groups:
+        for node in group.nodes + group.right_nodes:
+            if node.reports_to and node.reports_to in nr:
+                src, dst = nr[node.reports_to], nr[node.id]
+                els.append(_ar(_nid(), [
+                    (src["x"]+src["w"]/2, src["y"]+src["h"]),
+                    (dst["x"]+dst["w"]/2, dst["y"])
+                ], tc["ec"]))
+        for b in group.blocks:
+            for node in b.nodes:
+                if node.reports_to and node.reports_to in nr:
+                    src, dst = nr[node.reports_to], nr[node.id]
+                    els.append(_ar(_nid(), [
+                        (src["x"]+src["w"]/2, src["y"]+src["h"]),
+                        (dst["x"]+dst["w"]/2, dst["y"])
+                    ], tc["ec"]))
+            if b.edge_from and b.nodes and b.edge_from in nr:
+                src, dst = nr[b.edge_from], nr[b.nodes[0].id]
+                els.append(_ar(_nid(), [
+                    (src["x"]+src["w"]/2, src["y"]+src["h"]),
+                    (dst["x"]+dst["w"]/2, dst["y"])
+                ], tc["ec"]))
+
+    return json.dumps({
+        "type": "excalidraw", "version": 2, "source": "https://structviz",
+        "elements": els,
+        "appState": {"viewBackgroundColor": "#ffffff"},
+        "files": {}
+    }, ensure_ascii=False, indent=2)

structviz/generators/org.py

@@ -0,0 +1,300 @@
+from typing import Optional, List, Tuple
+from ..models import OrgChart, OrgNode, OrgBlock
+from ..themes import THEMES, parse_paper_size
+
+
+def _make_card(node: OrgNode, theme: dict, style_override: Optional[str] = None) -> str:
+    def _br(s):
+        return s.replace('\n', '<br/>')
+    style = style_override if style_override else node.style
+    if style == "external":
+        header_bg = theme["external_header_bg"]
+    elif style == "large":
+        header_bg = theme["card_header_bg"]
+        return (f'< <table border="0" cellborder="0" cellspacing="0" cellpadding="6">'
+                f'<tr><td bgcolor="{header_bg}"><font color="{theme["card_header_font"]}"><b>{_br(node.title)}</b></font></td></tr>'
+                f'</table> >')
+    else:
+        header_bg = theme["card_header_bg"]
+    body_bg = theme["card_body_bg"]
+    header_font = theme["card_header_font"]
+    label = f'< <table border="0" cellborder="0" cellspacing="0" cellpadding="3">'
+    label += f'<tr><td bgcolor="{header_bg}"><font color="{header_font}"><b>{_br(node.title)}</b></font></td></tr>'
+    if node.name:
+        label += f'<tr><td bgcolor="{body_bg}">{_br(node.name)}</td></tr>'
+    if node.role:
+        label += f'<tr><td bgcolor="{body_bg}"><font point-size="9">{_br(node.role)}</font></td></tr>'
+    label += '</table> >'
+    return label
+
+
+def _emit_node_def(node: OrgNode, theme: dict, lines: List[str], all_edges: set,
+                   in_block: bool = False):
+    card = _make_card(node, theme, style_override="large" if node.is_cluster_head else None)
+    if in_block and not node.is_cluster_head:
+        lines.append(f'"{node.id}" [label={card}, shape=box, '
+                     f'style="rounded,filled", fillcolor="{theme["dept_fillcolor"]}", '
+                     f'color="{theme["dept_border"]}"];')
+    else:
+        lines.append(f'"{node.id}" [label={card}, shape=plaintext];')
+    if node.reports_to:
+        all_edges.add((node.reports_to, node.id))
+
+
+def _emit_ids_rank(ids: List[str], lines: List[str], prev_last: Optional[str] = None) -> Optional[str]:
+    if not ids:
+        return prev_last
+    lines.append('{ rank=same; ' + ' '.join(f'"{x}"' for x in ids) + ' }')
+    for i in range(len(ids) - 1):
+        lines.append(f'"{ids[i]}" -> "{ids[i+1]}" [style=invis, weight=10];')
+    if prev_last:
+        lines.append(f'"{prev_last}" -> "{ids[0]}" [style=invis, weight=100];')
+    return ids[-1]
+
+
+def _group_anchor_ids(group) -> Tuple[Optional[str], Optional[str]]:
+    first = last = None
+    for lst in [group.nodes, group.right_nodes]:
+        if lst:
+            first = first or lst[0].id
+            last = lst[-1].id
+    for b in group.blocks:
+        if b.nodes:
+            first = first or b.nodes[0].id
+            last = b.nodes[-1].id
+    return first, last
+
+
+def _emit_block_subgraph(block: OrgBlock, theme: dict, lines: List[str],
+                         all_edges: set, is_right: bool, pad_w: float,
+                         row_gap: float = 1.0):
+    lines.append(f'subgraph cluster_{block.id} {{')
+    lines.append(f'label="{block.label}"; fontsize=12; '
+                 f'style="rounded,dashed"; color="{theme["card_border_color"]}"; '
+                 f'bgcolor="{theme["cluster_bg"]}";')
+    in_blk = not is_right
+    heads = [n for n in block.nodes if n.is_cluster_head]
+    depts = [n for n in block.nodes if not n.is_cluster_head]
+
+    for n in heads:
+        _emit_node_def(n, theme, lines, all_edges, in_block=in_blk)
+
+    mc = block.max_columns or 0
+    if mc > 0 and len(depts) > mc and not is_right:
+        chunks = [depts[i:i + mc] for i in range(0, len(depts), mc)]
+        prev_anchor = None
+        for chunk in chunks:
+            anchor = f"_anc_{block.id}_{len(lines)}"
+            lines.append(f'"{anchor}" [shape=point, width=0, style=invis];')
+            if prev_anchor:
+                lines.append(f'"{prev_anchor}" -> "{anchor}" [style=invis, weight=100];')
+                lines.append(f'"{prev_anchor}" -> "{chunk[0].id}" [style=invis, minlen={row_gap}];')
+            lines.append('{ rank=same;')
+            lines.append(f'"{anchor}";')
+            for n in chunk:
+                _emit_node_def(n, theme, lines, all_edges, in_block=in_blk)
+            lines.append('}')
+            lines.append(f'"{anchor}" -> "{chunk[0].id}" [style=invis, weight=100];')
+            for i in range(len(chunk) - 1):
+                lines.append(f'"{chunk[i].id}" -> "{chunk[i+1].id}" [style=invis, weight=10];')
+            prev_anchor = anchor
+    else:
+        for n in depts:
+            _emit_node_def(n, theme, lines, all_edges, in_block=in_blk)
+    lines.append('}')
+
+
+def generate_org_dot(chart: OrgChart, paper_size: Optional[str] = None,
+                     dpi: Optional[int] = None) -> str:
+    theme = THEMES.get(chart.meta.theme, THEMES["corporate"])
+    layout = chart.meta.layout
+    nodesep = layout.nodesep if layout else theme["nodesep"]
+    ranksep = layout.ranksep if layout else theme["ranksep"]
+    pad_w = layout.block_pad if layout else 0.15
+    row_gap_cfg = layout.row_gap if layout else 1.0
+    row_gap = max(1, round(row_gap_cfg))
+    def _to_minlen(v):
+        return max(1, round(v)) if v is not None else row_gap
+    global_max_cols = layout.max_columns if layout else 0
+
+    has_edge_from = any(b.edge_from for g in chart.groups for b in g.blocks)
+    compound = ' compound=true;' if has_edge_from else ''
+
+    lines = ['digraph G {']
+    lines.append(f'label="{chart.meta.title}"; labelloc=t; fontsize=14;')
+    lines.append(f'rankdir=TB; splines=ortho; newrank=true; center=true; ordering=out;{compound}')
+    ps = parse_paper_size(paper_size) if paper_size else None
+    if ps:
+        lines.append(f'size="{ps["size"]}"; ratio={ps["ratio"]}; margin=0;')
+        lines.append(f'ranksep=0.3; nodesep=0.15;')
+    else:
+        lines.append(f'ranksep={ranksep}; nodesep={nodesep};')
+    lines.append(f'dpi={dpi};') if dpi else None
+    lines.append(f'node [shape=plaintext fontname="{theme["node_default"]["fontname"]}" '
+                f'fontsize={theme["node_default"]["fontsize"]}];')
+    lines.append(f'edge [color="{theme["edge_color"]}" penwidth={theme["edge_penwidth"]} arrowsize=0.8];')
+
+    all_edges = set()
+    gap_edges = []
+
+    for group in chart.groups:
+        left_blocks = [b for b in group.blocks if b.position == "left"]
+        right_blocks = [b for b in group.blocks if b.position == "right"]
+        bottom_blocks = [b for b in group.blocks if b.position == "bottom"]
+        max_rc = group.max_right_columns or 0
+
+        # ── side blocks 子图 (left + right) ──
+        lb_nodes, rb_nodes = [], []
+        for b in left_blocks + right_blocks:
+            brg = _to_minlen(b.row_gap)
+            _emit_block_subgraph(b, theme, lines, all_edges, is_right=True, pad_w=pad_w, row_gap=brg)
+            if b.edge_from and b.nodes:
+                if b.position == "left":
+                    lines.append(f'"{b.edge_from}" -> "{b.nodes[0].id}";')
+                else:
+                    lines.append(f'"{b.edge_from}" -> "{b.nodes[0].id}" [lhead=cluster_{b.id}];')
+        lb_nodes = [n for b in left_blocks for n in b.nodes]
+        rb_nodes = [n for b in right_blocks for n in b.nodes]
+
+        # ── 主节点 + right_nodes rank ──
+        m_ids = [n.id for n in group.nodes]
+        r_ids = [n.id for n in group.right_nodes]
+
+        if group.offset and group.offset > 0:
+            sid = f"_shift_L{group.level}"
+            lines.append(f'"{sid}" [shape=point, width={group.offset}, style=invis];')
+            first = m_ids[0] if m_ids else (r_ids[0] if r_ids else None)
+            if first:
+                lines.append(f'"{sid}" -> "{first}" [style=invis, weight=100];')
+            m_ids = [sid] + m_ids
+
+        if max_rc > 0 and len(group.right_nodes) > max_rc:
+            if m_ids:
+                _emit_ids_rank(m_ids, lines)
+            r_chunks = [r_ids[i:i + max_rc] for i in range(0, len(r_ids), max_rc)]
+            prev_last = m_ids[-1] if m_ids else None
+            for chunk in r_chunks:
+                prev_last = _emit_ids_rank(chunk, lines, prev_last)
+        else:
+            if m_ids + r_ids and not (lb_nodes or rb_nodes):
+                ids = list(m_ids + r_ids)
+                nsep = group.nodesep if group.nodesep is not None else (layout.nodesep if layout else None)
+                if nsep and nsep > 0 and len(ids) > 1:
+                    spaced = [ids[0]]
+                    for k in range(1, len(ids)):
+                        gid = f"_gap_{group.level}_{k}"
+                        lines.append(f'"{gid}" [shape=point, width={nsep}, style=invis];')
+                        spaced.append(gid)
+                        spaced.append(ids[k])
+                    _emit_ids_rank(spaced, lines)
+                else:
+                    _emit_ids_rank(ids, lines)
+
+        # ── left blocks rank 约束 ──
+        if lb_nodes:
+            lb_ids = [n.id for n in lb_nodes]
+            lb_mc = left_blocks[0].max_columns if left_blocks else 0
+            if lb_mc > 0 and len(lb_ids) > lb_mc:
+                chunks = [lb_ids[i:i + lb_mc] for i in range(0, len(lb_ids), lb_mc)]
+                prev_last = None
+                for ci, chunk in enumerate(chunks):
+                    ids = chunk
+                    if ci == len(chunks) - 1 and (m_ids or r_ids):
+                        ids = ids + (m_ids if m_ids else r_ids)
+                    # 只输出 rank=same，不加不可见边（靠自然排序）
+                    lines.append('{ rank=same; ' + ' '.join(f'"{x}"' for x in ids) + ' }')
+                    if prev_last:
+                        lines.append(f'"{prev_last}" -> "{chunk[0]}" [style=invis, minlen={row_gap}];')
+                    prev_last = chunk[-1]
+            else:
+                if m_ids or r_ids:
+                    ids = lb_ids + (m_ids if m_ids else r_ids)
+                else:
+                    ids = lb_ids
+                lines.append('{ rank=same; ' + ' '.join(f'"{x}"' for x in ids) + ' }')
+
+        # ── right blocks: 同 rank=same 但不加行内边 (交给 Graphviz) ──
+        if rb_nodes:
+            rb_ids = [n.id for n in rb_nodes]
+            rb_mc = right_blocks[0].max_columns if right_blocks else 0
+            rb_gap = _to_minlen(right_blocks[0].row_gap) if right_blocks else row_gap
+            all_rb_ids = list(rb_ids)
+            if rb_mc > 0 and len(rb_ids) > rb_mc:
+                chunks = [rb_ids[i:i + rb_mc] for i in range(0, len(rb_ids), rb_mc)]
+                prev_last = None
+                for ci, chunk in enumerate(chunks):
+                    ids = chunk
+                    if ci == 0 and (m_ids or r_ids):
+                        ids = (m_ids if m_ids else r_ids) + chunk
+                    lines.append('{ rank=same; ' + ' '.join(f'"{x}"' for x in ids) + ' }')
+                    if prev_last:
+                        lines.append(f'"{prev_last}" -> "{chunk[0]}" [style=invis, minlen={rb_gap}];')
+                    prev_last = chunk[-1]
+            else:
+                ids = (m_ids if m_ids else r_ids) + rb_ids if (m_ids or r_ids) else rb_ids
+                lines.append('{ rank=same; ' + ' '.join(f'"{x}"' for x in ids) + ' }')
+
+        # ── bottom blocks ──
+        if bottom_blocks:
+            max_cols = group.max_columns if group.max_columns is not None else global_max_cols
+            eff_cols = max_cols if max_cols > 0 else len(bottom_blocks)
+            chunks = [bottom_blocks[i:i + eff_cols] for i in range(0, len(bottom_blocks), eff_cols)]
+            prev_row_heads = []
+            for chunk in chunks:
+                row_heads = [n for b in chunk for n in b.nodes if n.is_cluster_head]
+                if not row_heads:
+                    # 无 cluster head → 取每个 block 首节点对齐
+                    row_heads = [b.nodes[0] for b in chunk if b.nodes]
+                if row_heads:
+                    off_w = group.offset if group.offset else 0
+                    gap_w = group.nodesep if group.nodesep is not None else (layout.nodesep if layout else 0)
+                    p_l = f"_bal_L{group.level}"
+                    p_r = f"_bal_R{group.level}"
+                    lines.append(f'"{p_l}" [shape=point, width={off_w}, style=invis];')
+                    lines.append(f'"{p_r}" [shape=point, width={off_w}, style=invis];')
+                    # 插入间隔节点控制 block 间距
+                    rank_ids = [p_l]
+                    for j, h in enumerate(row_heads):
+                        rank_ids.append(h.id)
+                        if j < len(row_heads) - 1 and gap_w > 0:
+                            gid = f"_gap_{group.level}_{j}"
+                            lines.append(f'"{gid}" [shape=point, width={gap_w}, style=invis];')
+                            rank_ids.append(gid)
+                    rank_ids.append(p_r)
+                    _emit_ids_rank(rank_ids, lines)
+                if prev_row_heads and row_heads:
+                    lines.append(f'"{prev_row_heads[-1].id}" -> "{row_heads[0].id}" [style=invis, weight=100];')
+                prev_row_heads = row_heads
+                for b in chunk:
+                    brg = _to_minlen(b.row_gap)
+                    _emit_block_subgraph(b, theme, lines, all_edges, is_right=False, pad_w=pad_w, row_gap=brg)
+                    if b.edge_from and b.nodes:
+                        lines.append(f'"{b.edge_from}" -> "{b.nodes[0].id}" [lhead=cluster_{b.id}];')
+
+    # ── reports_to edges ──
+    for group in chart.groups:
+        for node in group.nodes + group.right_nodes:
+            if node.reports_to:
+                all_edges.add((node.reports_to, node.id))
+
+    # ── gap edges ──
+    for i in range(len(chart.groups) - 1):
+        g_curr, g_next = chart.groups[i], chart.groups[i + 1]
+        if g_curr.gap:
+            _, last_id = _group_anchor_ids(g_curr)
+            next_ids = [n.id for n in g_next.nodes + g_next.right_nodes]
+            for b in g_next.blocks:
+                next_ids.extend(n.id for n in b.nodes if n.is_cluster_head)
+            first_id = next_ids[len(next_ids) // 2] if next_ids else None
+            if not first_id:
+                first_id, _ = _group_anchor_ids(g_next)
+            if last_id and first_id:
+                gap_edges.append((last_id, first_id, g_curr.gap))
+
+    for src, dst in all_edges:
+        lines.append(f'"{src}" -> "{dst}";')
+    for src, dst, gap in gap_edges:
+        lines.append(f'"{src}" -> "{dst}" [style=invis, minlen={gap}];')
+
+    lines.append('}')
+    return '\n'.join(lines)

structviz/html_wrapper.py

@@ -0,0 +1,31 @@
+HTML_TEMPLATE = """
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="UTF-8">
+<title>{{ title }}</title>
+<style>
+  body { margin: 0; display: flex; justify-content: center; background: #f5f5f5; }
+  .container { max-width: 100%; }
+  svg { max-height: 100vh; }
+  .node:hover { filter: brightness(0.95); cursor: pointer; }
+  .edge:hover { stroke-width: 2.5; }
+  text { font-family: 'Helvetica Neue', Helvetica, Arial, sans-serif; }
+</style>
+</head>
+<body>
+<div class="container">
+{{ svg_content | safe }}
+</div>
+</body>
+</html>
+"""
+
+def generate_html(svg_path: str, title: str, output_html: str):
+    with open(svg_path, 'r', encoding='utf-8') as f:
+        svg = f.read()
+    from jinja2 import Template
+    template = Template(HTML_TEMPLATE)
+    html = template.render(title=title, svg_content=svg)
+    with open(output_html, 'w', encoding='utf-8') as f:
+        f.write(html)