SVGN Architecture
svgn
is designed as a native Rust port of svgo
, aiming to replicate its core architectural principles while leveraging Rust’s strengths for performance and reliability. The architecture closely mirrors svgo
’s modular design, consisting of a core engine, parser, stringifier, and a robust plugin system.
Core Components
1. Core Engine (svgn/src/optimizer.rs
)
Similar to svgo
’s lib/svgo.js
, the svgn
core engine orchestrates the SVG optimization process. It takes an SVG string and a configuration object, then applies a pipeline of plugins to the parsed SVG Abstract Syntax Tree (AST). The engine manages the order of plugin execution and handles multi-pass optimizations if configured.
2. Parser (svgn/src/parser.rs
)
The parser component is responsible for transforming an SVG string into an Abstract Syntax Tree (AST). In svgo
, this is handled by lib/parser.js
, which uses a SAX-like approach. svgn
implements its own efficient SVG parser in Rust, converting the raw SVG XML into a structured, traversable AST representation that plugins can operate on.
3. Plugins (svgn/src/plugins/
)
Plugins are the heart of svgn
’s optimization capabilities. Each plugin is a self-contained module that performs a specific optimization or transformation on the SVG AST. svgn
’s plugin system is designed to be compatible with svgo
’s plugin API concepts, allowing for a systematic porting of existing svgo
plugins.
- Modularity: Each optimization is encapsulated within its own plugin, promoting code organization and reusability.
- AST Transformation: Plugins receive and modify the SVG AST, enabling complex manipulations of SVG elements, attributes, and styles.
- Configurability: Plugins can be enabled, disabled, and configured with specific parameters via the
SvgnConfig
object.
4. Stringifier (svgn/src/stringifier.rs
)
After all plugins have processed the AST, the stringifier component converts the optimized AST back into a minified SVG string. This component is analogous to svgo
’s lib/stringifier.js
. The stringifier handles proper XML serialization, including attribute ordering, whitespace management, and numeric precision, to ensure the smallest possible output size while maintaining valid SVG syntax.
5. Command-Line Interface (CLI) (svgn/src/bin/svgn.rs
)
The svgn
CLI provides a user-friendly interface for optimizing SVG files directly from the terminal. It parses command-line arguments, loads configuration, invokes the core optimization engine, and outputs the results. This component mirrors the functionality of svgo
’s bin/svgo
and lib/svgo-node.js
.
Design Principles
svgn
’s architecture is guided by several key design principles:
- Performance: Leveraging Rust’s capabilities for zero-cost abstractions, memory safety, and concurrency to achieve superior optimization speeds.
- Functional Parity: Ensuring that
svgn
produces identical optimization results tosvgo
for the same inputs and configurations. - Modularity: Maintaining a clear separation of concerns between parsing, optimization, and stringification, and promoting a plugin-based approach for extensibility.
- API Compatibility: Designing the Rust API to be conceptually similar to
svgo
’s JavaScript API where appropriate, to ease migration for developers. - WASM Readiness: Structuring the codebase to facilitate efficient compilation to WebAssembly, enabling broad deployment scenarios.
By adhering to these principles, svgn
aims to be a robust, high-performance, and functionally equivalent alternative to svgo
in the Rust ecosystem.