drawio2tikz 0.1.0__tar.gz

drawio2tikz-0.1.0/PKG-INFO

@@ -0,0 +1,160 @@
+Metadata-Version: 2.4
+Name: drawio2tikz
+Version: 0.1.0
+Summary: Convert diagrams.net/draw.io diagrams to TikZ via SVG.
+Keywords: drawio,diagrams.net,svg,tikz,latex
+Author: Daiki Okayama
+Author-email: Daiki Okayama <lawliet.d.k.m@gmail.com>
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Multimedia :: Graphics :: Editors :: Vector-Based
+Classifier: Topic :: Text Processing :: Markup :: LaTeX
+Requires-Dist: rich>=15.0
+Requires-Dist: svg2tikz>=3.3.4
+Requires-Dist: typer>=0.15
+Requires-Python: >=3.14
+Project-URL: Homepage, https://github.com/daikiokayama/drawio2tikz
+Project-URL: Issues, https://github.com/daikiokayama/drawio2tikz/issues
+Description-Content-Type: text/markdown
+
+# drawio2tikz
+
+`drawio2tikz` is a thin wrapper around [`svg2tikz`](https://github.com/xyz2tex/svg2tikz) that converts draw.io diagrams to TikZ code for embedding in LaTeX documents.
+
+## Features
+
+- Converts either a single draw.io page or all pages
+- Preserves label colors, bold text, font sizes, and simple line breaks
+- **Ignores draw.io font family names**, allowing output to use the host LaTeX document font
+- Removes draw.io SVG CSS that `svg2tikz` cannot parse, including `light-dark(...)` from draw.io's dark mode color scheme
+- Restores draw.io labels emitted as SVG `foreignObject` elements, which draw.io exports as HTML fragments
+
+## Requirements
+
+- **Python 3.14 or newer**
+- **`drawio` CLI** available on `PATH` (install from [diagrams.net](https://diagrams.net) or via Homebrew: `brew install --cask drawio`)
+
+## Installation
+
+### Homebrew (macOS)
+
+```bash
+brew install drawio2tikz
+```
+
+### pip / uv
+
+Install from PyPI:
+
+```bash
+uv tool install drawio2tikz
+```
+
+Or with pip:
+
+```bash
+pip install drawio2tikz
+```
+
+### Development Setup
+
+Clone the repository and install in development mode:
+
+```bash
+git clone https://github.com/daikiokayama/drawio2tikz.git
+cd drawio2tikz
+uv sync
+uv run drawio2tikz --help
+```
+
+## Usage
+
+### Basic Usage
+
+Convert a single page from a draw.io file to TikZ:
+
+```bash
+drawio2tikz path/to/figure.drawio -o output_dir
+```
+
+This generates `figure.tikz` in the output directory.
+
+### Convert All Pages
+
+To convert all pages in a multi-page `.drawio` file:
+
+```bash
+drawio2tikz path/to/multipage.drawio --all-pages -o output_dir
+```
+
+Each page is saved as `figure_page{N}.tikz`.
+
+### Keep Intermediate SVG
+
+To debug or inspect the intermediate SVG (after sanitization):
+
+```bash
+drawio2tikz path/to/figure.drawio -o output_dir --keep-svg --svg-dir output_dir/svg
+```
+
+### View Help
+
+```bash
+drawio2tikz --help
+```
+
+## LaTeX Setup
+
+Add these packages to your LaTeX document preamble:
+
+```tex
+\usepackage{xcolor}
+\usepackage{tikz}
+```
+
+Include the generated TikZ file:
+
+```tex
+\input{path/to/figure.tikz}
+```
+
+For support of arbitrary large font sizes, use a scalable font:
+
+```tex
+\usepackage{mlmodern}
+```
+
+### Example LaTeX Document
+
+```tex
+\documentclass{article}
+\usepackage{xcolor}
+\usepackage{tikz}
+\usepackage{mlmodern}
+
+\begin{document}
+
+\section{My Diagram}
+
+\begin{figure}
+  \centering
+  \input{figures/diagram.tikz}
+  \caption{A diagram created in draw.io}
+\end{figure}
+
+\end{document}
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to open issues or submit pull requests on [GitHub](https://github.com/daikiokayama/drawio2tikz).
+
+## License
+
+MIT

drawio2tikz-0.1.0/README.md

@@ -0,0 +1,135 @@
+# drawio2tikz
+
+`drawio2tikz` is a thin wrapper around [`svg2tikz`](https://github.com/xyz2tex/svg2tikz) that converts draw.io diagrams to TikZ code for embedding in LaTeX documents.
+
+## Features
+
+- Converts either a single draw.io page or all pages
+- Preserves label colors, bold text, font sizes, and simple line breaks
+- **Ignores draw.io font family names**, allowing output to use the host LaTeX document font
+- Removes draw.io SVG CSS that `svg2tikz` cannot parse, including `light-dark(...)` from draw.io's dark mode color scheme
+- Restores draw.io labels emitted as SVG `foreignObject` elements, which draw.io exports as HTML fragments
+
+## Requirements
+
+- **Python 3.14 or newer**
+- **`drawio` CLI** available on `PATH` (install from [diagrams.net](https://diagrams.net) or via Homebrew: `brew install --cask drawio`)
+
+## Installation
+
+### Homebrew (macOS)
+
+```bash
+brew install drawio2tikz
+```
+
+### pip / uv
+
+Install from PyPI:
+
+```bash
+uv tool install drawio2tikz
+```
+
+Or with pip:
+
+```bash
+pip install drawio2tikz
+```
+
+### Development Setup
+
+Clone the repository and install in development mode:
+
+```bash
+git clone https://github.com/daikiokayama/drawio2tikz.git
+cd drawio2tikz
+uv sync
+uv run drawio2tikz --help
+```
+
+## Usage
+
+### Basic Usage
+
+Convert a single page from a draw.io file to TikZ:
+
+```bash
+drawio2tikz path/to/figure.drawio -o output_dir
+```
+
+This generates `figure.tikz` in the output directory.
+
+### Convert All Pages
+
+To convert all pages in a multi-page `.drawio` file:
+
+```bash
+drawio2tikz path/to/multipage.drawio --all-pages -o output_dir
+```
+
+Each page is saved as `figure_page{N}.tikz`.
+
+### Keep Intermediate SVG
+
+To debug or inspect the intermediate SVG (after sanitization):
+
+```bash
+drawio2tikz path/to/figure.drawio -o output_dir --keep-svg --svg-dir output_dir/svg
+```
+
+### View Help
+
+```bash
+drawio2tikz --help
+```
+
+## LaTeX Setup
+
+Add these packages to your LaTeX document preamble:
+
+```tex
+\usepackage{xcolor}
+\usepackage{tikz}
+```
+
+Include the generated TikZ file:
+
+```tex
+\input{path/to/figure.tikz}
+```
+
+For support of arbitrary large font sizes, use a scalable font:
+
+```tex
+\usepackage{mlmodern}
+```
+
+### Example LaTeX Document
+
+```tex
+\documentclass{article}
+\usepackage{xcolor}
+\usepackage{tikz}
+\usepackage{mlmodern}
+
+\begin{document}
+
+\section{My Diagram}
+
+\begin{figure}
+  \centering
+  \input{figures/diagram.tikz}
+  \caption{A diagram created in draw.io}
+\end{figure}
+
+\end{document}
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to open issues or submit pull requests on [GitHub](https://github.com/daikiokayama/drawio2tikz).
+
+## License
+
+MIT

drawio2tikz-0.1.0/pyproject.toml

@@ -0,0 +1,60 @@
+[build-system]
+requires = ["uv_build>=0.8.14,<0.9.0"]
+build-backend = "uv_build"
+
+[project]
+name = "drawio2tikz"
+version = "0.1.0"
+description = "Convert diagrams.net/draw.io diagrams to TikZ via SVG."
+readme = "README.md"
+authors = [{ name = "Daiki Okayama", email = "lawliet.d.k.m@gmail.com" }]
+requires-python = ">=3.14"
+license = "MIT"
+keywords = ["drawio", "diagrams.net", "svg", "tikz", "latex"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Environment :: Console",
+  "Intended Audience :: Science/Research",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.14",
+  "Operating System :: OS Independent",
+  "Topic :: Multimedia :: Graphics :: Editors :: Vector-Based",
+  "Topic :: Text Processing :: Markup :: LaTeX",
+]
+dependencies = ["rich>=15.0", "svg2tikz>=3.3.4", "typer>=0.15"]
+
+[project.urls]
+Homepage = "https://github.com/daikiokayama/drawio2tikz"
+Issues = "https://github.com/daikiokayama/drawio2tikz/issues"
+
+[project.scripts]
+drawio2tikz = "drawio2tikz.cli:app"
+
+[dependency-groups]
+dev = ["basedpyright>=1.34.0", "pytest>=9.0", "ruff>=0.8"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py314"
+
+[tool.ruff.lint]
+select = ["ALL"]
+ignore = [
+  "E501", # Line too long
+  "D203", # Insert 1 blank line before class docstring
+  "D213", # Multi-line docstring summary should start at the next line
+  "S101", # Use of assert (standard in pytest)
+  "PLR0913", # Too many arguments (CLI requirement for Typer)
+]
+
+[tool.basedpyright]
+typeCheckingMode = "strict"
+venvPath = "."
+venv = ".venv"
+stubPath = "./stubs"
+
+[tool.uv.workspace]
+members = [
+    "test",
+]

drawio2tikz-0.1.0/src/drawio2tikz/__init__.py

@@ -0,0 +1,5 @@
+"""Convert diagrams.net/draw.io diagrams to TikZ."""
+
+from .converter import ConversionResult, ConvertOptions, convert
+
+__all__ = ["ConversionResult", "ConvertOptions", "convert"]

drawio2tikz-0.1.0/src/drawio2tikz/__main__.py

@@ -0,0 +1,5 @@
+"""Entry point for drawio2tikz CLI."""
+
+from .cli import app
+
+app()

drawio2tikz-0.1.0/src/drawio2tikz/cli.py

@@ -0,0 +1,117 @@
+"""Command-line interface for drawio2tikz."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Annotated
+
+import typer
+from rich.console import Console
+
+from .converter import ConvertOptions, convert
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+app = typer.Typer(
+    add_completion=False,
+    help="Convert diagrams.net/draw.io diagrams to TikZ via sanitized SVG.",
+)
+console = Console()
+
+
+@app.command()
+def main(
+    input_path: Annotated[
+        Path,
+        typer.Argument(exists=True, dir_okay=False, readable=True, help="Input .drawio file."),
+    ],
+    output: Annotated[
+        Path | None,
+        typer.Option("--output", "-o", help="Output .tex file or output directory."),
+    ] = None,
+    page_index: Annotated[
+        int,
+        typer.Option("--page-index", min=1, help="1-based draw.io page index."),
+    ] = 1,
+    *,
+    all_pages: Annotated[
+        bool,
+        typer.Option("--all-pages", help="Export every page found in a .drawio file."),
+    ] = False,
+    keep_svg: Annotated[
+        bool,
+        typer.Option("--keep-svg", help="Keep the sanitized intermediate SVG."),
+    ] = False,
+    svg_dir: Annotated[
+        Path | None,
+        typer.Option("--svg-dir", help="Directory for kept SVG files. Requires --keep-svg."),
+    ] = None,
+    drawio_bin: Annotated[
+        str,
+        typer.Option("--drawio-bin", help="draw.io CLI executable."),
+    ] = "drawio",
+    output_unit: Annotated[
+        str,
+        typer.Option("--output-unit", help="Output unit passed to svg2tikz."),
+    ] = "pt",
+    scale: Annotated[
+        float,
+        typer.Option("--scale", help="Scale passed to svg2tikz."),
+    ] = 1.0,
+    round_number: Annotated[
+        int,
+        typer.Option("--round-number", min=0, help="Coordinate precision for svg2tikz."),
+    ] = 3,
+    texmode: Annotated[
+        str,
+        typer.Option("--texmode", help="svg2tikz text mode. raw preserves injected TeX labels."),
+    ] = "raw",
+    markings: Annotated[
+        str,
+        typer.Option("--markings", help="svg2tikz marker handling."),
+    ] = "interpret",
+    quiet: Annotated[
+        bool,
+        typer.Option("--quiet", "-q", help="Suppress external command echoing."),
+    ] = False,
+) -> None:
+    """Convert draw.io diagrams to TikZ LaTeX code."""
+    if svg_dir and not keep_svg:
+        msg = "--svg-dir requires --keep-svg"
+        raise typer.BadParameter(msg)
+
+    options = ConvertOptions(
+        input_path=input_path,
+        output=output,
+        page_index=page_index,
+        all_pages=all_pages,
+        keep_svg=keep_svg,
+        svg_dir=svg_dir,
+        drawio_bin=drawio_bin,
+        output_unit=output_unit,
+        scale=scale,
+        round_number=round_number,
+        texmode=texmode,
+        markings=markings,
+        quiet=quiet,
+    )
+
+    try:
+        results = convert(options)
+    except Exception as exc:
+        console.print(f"[red]drawio2tikz:[/red] {exc}")
+        raise typer.Exit(1) from exc
+
+    for result in results:
+        svg_note = f", svg: {result.svg_path}" if result.svg_path else ""
+        console.print(f"wrote: [green]{result.tex_path}[/green]{svg_note}")
+        if result.remaining_foreign_objects:
+            console.print(
+                "[yellow]warning:[/yellow] sanitized SVG still contains "
+                f"{result.remaining_foreign_objects} foreignObject node(s); "
+                "some draw.io HTML text may be omitted.",
+            )
+        if result.text_nodes:
+            console.print(f"note: sanitized SVG contains {result.text_nodes} SVG text node(s).")
+
+    console.print(f"converted {len(results)} page(s)")

drawio2tikz-0.1.0/src/drawio2tikz/converter.py

@@ -0,0 +1,209 @@
+"""SVG to TikZ conversion with sanitization for draw.io diagrams."""
+
+from __future__ import annotations
+
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+from contextlib import contextmanager
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from svg2tikz import convert_svg
+
+from .drawio import count_pages, drawio_stem, parse_labels
+from .svg import sanitize_svg
+
+if TYPE_CHECKING:
+    from collections.abc import Generator
+
+    from .drawio import Label
+
+XML_DECL_RE = re.compile(r"^\s*<\?xml[^>]*\?>\s*", re.IGNORECASE)
+DOCTYPE_RE = re.compile(r"^\s*<!DOCTYPE[^>]*(?:\[[\s\S]*?\]\s*)?>\s*", re.IGNORECASE)
+
+
+@dataclass(frozen=True)
+class ConvertOptions:
+    """Options for SVG to TikZ conversion."""
+
+    input_path: Path
+    output: Path | None = None
+    page_index: int = 1
+    all_pages: bool = False
+    keep_svg: bool = False
+    svg_dir: Path | None = None
+    drawio_bin: str = "drawio"
+    output_unit: str = "pt"
+    scale: float = 1.0
+    round_number: int = 3
+    texmode: str = "raw"
+    markings: str = "interpret"
+    quiet: bool = False
+
+
+@dataclass(frozen=True)
+class ConversionResult:
+    """Result of a single conversion."""
+
+    tex_path: Path
+    svg_path: Path | None
+    remaining_foreign_objects: int
+    text_nodes: int
+
+
+def convert(options: ConvertOptions) -> list[ConversionResult]:
+    """Convert a draw.io file to TikZ LaTeX code."""
+    if not options.input_path.exists():
+        raise FileNotFoundError(options.input_path)
+    if shutil.which(options.drawio_bin) is None and not Path(options.drawio_bin).exists():
+        msg = f"draw.io CLI not found: {options.drawio_bin}"
+        raise RuntimeError(msg)
+
+    labels = parse_labels(options.input_path)
+    page_indexes = _page_indexes(options)
+
+    return [_convert_one(options, labels, page_index) for page_index in page_indexes]
+
+
+def _page_indexes(options: ConvertOptions) -> list[int]:
+    """Get list of page indexes to convert."""
+    if not options.all_pages:
+        return [options.page_index]
+
+    page_count = count_pages(options.input_path)
+    if page_count == 0:
+        msg = "--all-pages needs a plain .drawio XML file with diagram pages."
+        raise RuntimeError(msg)
+    return list(range(1, page_count + 1))
+
+
+def _convert_one(
+    options: ConvertOptions,
+    labels: dict[str, Label],
+    page_index: int,
+) -> ConversionResult:
+    """Convert a single page to TikZ."""
+    tex_path = _default_output_path(
+        options.input_path,
+        options.output,
+        page_index,
+        all_pages=options.all_pages,
+    )
+    tex_path.parent.mkdir(parents=True, exist_ok=True)
+
+    with tempfile.TemporaryDirectory(prefix="drawio2tikz-") as tmp:
+        tmp_dir = Path(tmp)
+        raw_svg = tmp_dir / f"{tex_path.stem}.raw.svg"
+        sanitized_svg = tmp_dir / f"{tex_path.stem}.svg"
+
+        _run_drawio_export(options, page_index, raw_svg)
+        stats = sanitize_svg(raw_svg, sanitized_svg, labels)
+
+        kept_svg = None
+        if options.keep_svg:
+            svg_dir = options.svg_dir or tex_path.parent
+            svg_dir.mkdir(parents=True, exist_ok=True)
+            kept_svg = svg_dir / f"{tex_path.stem}.svg"
+            shutil.copyfile(sanitized_svg, kept_svg)
+
+        tikz = _convert_svg_source(
+            sanitized_svg.read_text(encoding="utf-8"),
+            options,
+        )
+        tex_path.write_text(
+            _source_comment(options.input_path, page_index) + tikz,
+            encoding="utf-8",
+        )
+
+    return ConversionResult(
+        tex_path=tex_path,
+        svg_path=kept_svg,
+        remaining_foreign_objects=stats.remaining_foreign_objects,
+        text_nodes=stats.text_nodes,
+    )
+
+
+def _run_drawio_export(options: ConvertOptions, page_index: int, raw_svg: Path) -> None:
+    """Run draw.io CLI to export SVG."""
+    command = [
+        options.drawio_bin,
+        "--export",
+        "--format",
+        "svg",
+        "--page-index",
+        str(page_index),
+        "--output",
+        str(raw_svg),
+        str(options.input_path),
+    ]
+    if not options.quiet:
+        sys.stdout.write(f"+ {' '.join(command)}\n")
+        sys.stdout.flush()
+    subprocess.run(command, check=True)  # noqa: S603
+
+
+def _convert_svg_source(svg_source: str, options: ConvertOptions) -> str:
+    """Convert SVG source to TikZ code."""
+    # svg2tikz exposes a library API, but internally it still calls
+    # argparse.parse_args(). Isolate it from drawio2tikz's CLI arguments.
+    with _isolated_argv():
+        result: str = convert_svg(
+            _strip_xml_prolog(svg_source),
+            no_output=True,
+            returnstring=True,
+            codeoutput="figonly",
+            output_unit=options.output_unit,
+            texmode=options.texmode,
+            markings=options.markings,
+            arrow="stealth",
+            scale=options.scale,
+            round_number=options.round_number,
+        )
+        return result
+
+
+def _strip_xml_prolog(svg_source: str) -> str:
+    """Strip XML declaration and DOCTYPE from SVG source."""
+    svg_source = XML_DECL_RE.sub("", svg_source, count=1)
+    return DOCTYPE_RE.sub("", svg_source, count=1)
+
+
+@contextmanager
+def _isolated_argv() -> Generator[None]:
+    """Context manager to isolate sys.argv for svg2tikz."""
+    original = sys.argv
+    sys.argv = ["drawio2tikz-svg2tikz"]
+    try:
+        yield
+    finally:
+        sys.argv = original
+
+
+def _default_output_path(
+    input_path: Path,
+    output: Path | None,
+    page_index: int,
+    *,
+    all_pages: bool,
+) -> Path:
+    """Determine output path for TikZ file."""
+    stem = drawio_stem(input_path)
+    filename = f"{stem}-{page_index:02d}.tex" if all_pages else f"{stem}.tex"
+
+    if output is None:
+        return input_path.parent / "tikz" / filename
+    if output.suffix == ".tex" and not all_pages:
+        return output
+    return output / filename
+
+
+def _source_comment(input_path: Path, page_index: int) -> str:
+    """Generate LaTeX comment with conversion metadata."""
+    return (
+        f"% Generated from {input_path} page {page_index} via drawio SVG and svg2tikz.\n"
+        "% The intermediate SVG was sanitized by drawio2tikz.\n"
+    )

drawio2tikz-0.1.0/src/drawio2tikz/drawio.py

@@ -0,0 +1,232 @@
+"""Parse and handle labels from draw.io diagrams."""
+
+from __future__ import annotations
+
+import re
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass
+from html.parser import HTMLParser
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+DRAWIO_PX_TO_TEX_PT = 0.75
+FONT_SIZE_RE = re.compile(r"font-size:\s*([0-9.]+)px", re.IGNORECASE)
+CSS_COLOR_RE = re.compile(r"color:\s*([^;]+)", re.IGNORECASE)
+RGB_COLOR_RE = re.compile(r"rgba?\((\d+),\s*(\d+),\s*(\d+)(?:,\s*[^)]+)?\)", re.IGNORECASE)
+HEX_COLOR_RE = re.compile(r"#([0-9a-fA-F]{6})")
+FONT_WEIGHT_RE = re.compile(r"font-weight:\s*([^;]+)", re.IGNORECASE)
+
+TEX_SPECIALS = {
+    "&": r"\&",
+    "%": r"\%",
+    "#": r"\#",
+    "_": r"\_",
+    "{": r"\{",
+    "}": r"\}",
+}
+
+
+@dataclass(frozen=True)
+class LabelLine:
+    """A single line of text in a label."""
+
+    text: str
+    font_size: float | None
+
+
+@dataclass(frozen=True)
+class Label:
+    """A label extracted from a draw.io cell."""
+
+    lines: list[LabelLine]
+    font_size: float | None
+
+
+@dataclass
+class TextStyle:
+    """Text styling attributes."""
+
+    bold: bool = False
+    color: str | None = None
+    font_size: float | None = None
+
+
+@dataclass
+class TextRun:
+    """A run of text with associated styling."""
+
+    text: str
+    bold: bool = False
+    color: str | None = None
+    font_size: float | None = None
+
+
+class DrawioLabelParser(HTMLParser):
+    """Parse HTML labels from draw.io cells into TeX-compatible text."""
+
+    def __init__(self) -> None:
+        """Initialize the parser."""
+        super().__init__(convert_charrefs=True)
+        self.lines: list[list[TextRun]] = [[]]
+        self.stack: list[TextStyle] = [TextStyle()]
+        self.pushed_tags: list[str] = []
+
+    @property
+    def current_style(self) -> TextStyle:
+        """Get the current text style."""
+        return self.stack[-1]
+
+    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
+        """Handle start of HTML tags."""
+        tag = tag.lower()
+        if tag in {"div", "p"}:
+            self._newline()
+            self._push_style(tag, attrs)
+        elif tag == "br":
+            self._newline()
+        elif tag in {"b", "strong"}:
+            self._push_style(tag, attrs, force_bold=True)
+        elif tag in {"font", "span", "i", "em", "u"}:
+            self._push_style(tag, attrs)
+
+    def handle_endtag(self, tag: str) -> None:
+        """Handle end of HTML tags."""
+        tag = tag.lower()
+        if tag in {"div", "p", "b", "strong", "font", "span", "i", "em", "u"}:
+            self._pop_style(tag)
+
+    def handle_data(self, data: str) -> None:
+        """Handle text data."""
+        text = data.replace("\xa0", " ")
+        if not text:
+            return
+        style = self.current_style
+        self.lines[-1].append(
+            TextRun(
+                text=text,
+                bold=style.bold,
+                color=style.color,
+                font_size=style.font_size,
+            ),
+        )
+
+    def _newline(self) -> None:
+        if self.lines[-1]:
+            self.lines.append([])
+
+    def _push_style(
+        self,
+        tag: str,
+        attrs: list[tuple[str, str | None]],
+        *,
+        force_bold: bool = False,
+    ) -> None:
+        style = TextStyle(**self.current_style.__dict__)
+        parsed = _style_from_attrs(attrs)
+        style.color = parsed.color or style.color
+        style.font_size = parsed.font_size or style.font_size
+        style.bold = style.bold or parsed.bold or force_bold
+        self.stack.append(style)
+        self.pushed_tags.append(tag)
+
+    def _pop_style(self, tag: str) -> None:
+        if tag not in self.pushed_tags:
+            return
+        index = len(self.pushed_tags) - 1 - self.pushed_tags[::-1].index(tag)
+        del self.pushed_tags[index]
+        del self.stack[index + 1]
+
+
+def parse_labels(path: Path) -> dict[str, Label]:
+    """Parse all labels from a draw.io file."""
+    root = ET.parse(path).getroot()  # noqa: S314
+    labels: dict[str, Label] = {}
+
+    for cell in root.findall(".//mxCell"):
+        cell_id = cell.get("id")
+        value = cell.get("value")
+        if not cell_id or not value:
+            continue
+        label = parse_label(value)
+        if label.lines:
+            labels[cell_id] = label
+
+    return labels
+
+
+def count_pages(path: Path) -> int:
+    """Count the number of pages in a draw.io file."""
+    root = ET.parse(path).getroot()  # noqa: S314
+    return len(root.findall("diagram"))
+
+
+def drawio_stem(path: Path) -> str:
+    """Extract the stem of a draw.io file name."""
+    name = path.name
+    if name.endswith(".drawio.png"):
+        return name[: -len(".drawio.png")]
+    if name.endswith(".drawio"):
+        return name[: -len(".drawio")]
+    return path.stem
+
+
+def parse_label(value: str) -> Label:
+    """Parse a single label from HTML string."""
+    parser = DrawioLabelParser()
+    parser.feed(value)
+
+    lines: list[LabelLine] = []
+    font_sizes: list[float] = []
+
+    for runs in parser.lines:
+        line_font_sizes = [run.font_size for run in runs if run.font_size]
+        font_sizes.extend(line_font_sizes)
+        line_text = _text_from_runs(runs)
+        if line_text:
+            first_font = line_font_sizes[0] if line_font_sizes else None
+            lines.append(LabelLine(text=line_text, font_size=first_font))
+
+    if not lines:
+        return Label(lines=[], font_size=None)
+
+    label_font_size = font_sizes[0] if font_sizes else None
+    return Label(lines=lines, font_size=label_font_size)
+
+
+def _text_from_runs(runs: list[TextRun]) -> str:
+    parts: list[str] = []
+    for run in runs:
+        text = run.text
+        for char, replacement in TEX_SPECIALS.items():
+            text = text.replace(char, replacement)
+        if run.bold:
+            text = rf"\textbf{{{text}}}"
+        if run.color:
+            text = rf"\textcolor[HTML]{{{run.color}}}{{{text}}}"
+        parts.append(text)
+    return "".join(parts)
+
+
+def _style_from_attrs(attrs: list[tuple[str, str | None]]) -> TextStyle:
+    style = TextStyle()
+    attrs_dict = dict(attrs)
+    if "style" in attrs_dict:
+        css = attrs_dict["style"] or ""
+        if match := FONT_SIZE_RE.search(css):
+            style.font_size = float(match.group(1))
+        if match := CSS_COLOR_RE.search(css):
+            color_str = match.group(1).strip()
+            if color_match := RGB_COLOR_RE.search(color_str):
+                r, g, b = color_match.groups()
+                style.color = f"{int(r):02X}{int(g):02X}{int(b):02X}"
+            elif hex_match := HEX_COLOR_RE.search(color_str):
+                style.color = hex_match.group(1).upper()
+    if "color" in attrs_dict and (
+        hex_match := HEX_COLOR_RE.search(attrs_dict["color"] or "")
+    ):
+        style.color = hex_match.group(1).upper()
+    if "weight" in attrs_dict and attrs_dict["weight"] in {"bold", "700"}:
+        style.bold = True
+    return style

drawio2tikz-0.1.0/src/drawio2tikz/svg.py

@@ -0,0 +1,120 @@
+"""SVG sanitization for draw.io diagrams."""
+
+from __future__ import annotations
+
+import html
+import re
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from .drawio import DRAWIO_PX_TO_TEX_PT, Label, LabelLine
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+STYLE_ELEMENT_RE = re.compile(r"<style\b[^>]*>.*?</style>", re.DOTALL)
+STYLE_ATTR_RE = re.compile(r'\sstyle="[^"]*"')
+SWITCH_FOREIGN_OBJECT_RE = re.compile(
+    r"<switch>\s*<foreignObject\b.*?</foreignObject>\s*<image\s+([^>]*)/>\s*</switch>",
+    re.DOTALL,
+)
+ATTR_RE = re.compile(r'([:\w-]+)="([^"]*)"')
+
+
+@dataclass(frozen=True)
+class SVGStats:
+    """Statistics about SVG sanitization."""
+
+    remaining_foreign_objects: int
+    text_nodes: int
+
+
+def sanitize_svg(
+    raw_svg: Path,
+    sanitized_svg: Path,
+    labels: dict[str, Label],
+) -> SVGStats:
+    """Sanitize SVG by converting foreign objects to text nodes."""
+    text = raw_svg.read_text(encoding="utf-8")
+    text = _restore_foreign_object_text(text, labels)
+    text = STYLE_ELEMENT_RE.sub("", text)
+    text = STYLE_ATTR_RE.sub("", text)
+    sanitized_svg.write_text(text, encoding="utf-8")
+    return SVGStats(
+        remaining_foreign_objects=text.count("foreignObject"),
+        text_nodes=text.count("<text"),
+    )
+
+
+def _restore_foreign_object_text(
+    svg_text: str,
+    labels: dict[str, Label],
+) -> str:
+    """Restore text in foreign objects using parsed labels."""
+
+    def replace(match: re.Match[str]) -> str:
+        cell_id = _nearest_cell_id(svg_text, match.start())
+        if not cell_id or cell_id not in labels:
+            return match.group(0)
+        label_obj = labels[cell_id]
+        replacement = _text_svg_for_label(label_obj, _parse_attrs(match.group(1)))
+        return replacement or match.group(0)
+
+    return SWITCH_FOREIGN_OBJECT_RE.sub(replace, svg_text)
+
+
+def _nearest_cell_id(svg_text: str, offset: int) -> str | None:
+    """Find the nearest cell ID before the given offset."""
+    marker = 'data-cell-id="'
+    start = svg_text.rfind(marker, 0, offset)
+    if start == -1:
+        return None
+    start += len(marker)
+    end = svg_text.find('"', start)
+    if end == -1:
+        return None
+    return svg_text[start:end]
+
+
+def _parse_attrs(raw_attrs: str) -> dict[str, str]:
+    """Parse attributes from a string."""
+    return {name: html.unescape(value) for name, value in ATTR_RE.findall(raw_attrs)}
+
+
+def _text_svg_for_label(label: Label, image_attrs: dict[str, str]) -> str:
+    """Generate SVG text nodes for a label."""
+    try:
+        x = float(image_attrs["x"])
+        y = float(image_attrs["y"])
+        width = float(image_attrs["width"])
+        height = float(image_attrs["height"])
+    except (KeyError, ValueError):
+        return ""
+
+    if not label.lines:
+        return ""
+
+    font_size = label.font_size or height / len(label.lines) * 0.8
+    font_size = max(8.0, min(font_size, height * 0.95))
+    line_height = font_size * 1.2
+    first_baseline = y + height / 2 - (len(label.lines) - 1) * line_height / 2 + font_size * 0.35
+    cx = x + width / 2
+
+    text_nodes: list[str] = []
+    for index, line in enumerate(label.lines):
+        line_text = _line_text_with_fallback_size(line, font_size)
+        text_nodes.append(
+            f'<text x="{cx:.3f}" y="{first_baseline + index * line_height:.3f}" '
+            f'text-anchor="middle" font-size="{font_size:.3f}px">'
+            f"{html.escape(line_text, quote=False)}</text>",
+        )
+    return "".join(text_nodes)
+
+
+def _line_text_with_fallback_size(line: LabelLine, font_size_px: float) -> str:
+    """Generate TeX text for a label line with fallback font size."""
+    if line.font_size:
+        return line.text
+    size_pt = font_size_px * DRAWIO_PX_TO_TEX_PT
+    leading_pt = size_pt * 1.2
+    return rf"\fontsize{{{size_pt:.1f}pt}}{{{leading_pt:.1f}pt}}\selectfont {line.text}"