DEV Community

Cover image for The Last SVG Tool You’ll Ever Need: A Zero-Dependency Alternative to SVGR
navid rezadoost
navid rezadoost

Posted on Edited on

The Last SVG Tool You’ll Ever Need: A Zero-Dependency Alternative to SVGR

The Last SVG Tool You’ll Ever Need: SVGER-CLI 4.1, a Zero-Dependency Core, and Nine Framework Targets

Updated October 2026 — A closer look at unified SVG generation, build integrations, security, and reproducible workflows.

Tags: #react #vue #svelte #opensource

The SVG Problem Hasn't Disappeared. It's Just Become More Complicated.

Imagine working on a frontend platform with multiple applications.

One application uses React. Another uses Vue. Your design system needs to support Angular. A newer project uses Svelte, while a mobile application uses React Native.

All of them need the same icons.

The SVG source files are identical, but the surrounding development workflows are not.

For React, you might use SVGR. For Vue, perhaps a Vite SVG loader. Svelte, Angular, and React Native introduce their own component formats, runtime requirements, and conventions.

Each solution can work well independently. The difficulty appears when you're responsible for maintaining a consistent SVG pipeline across multiple frameworks.

You start asking questions:

  • How do we enforce consistent component naming?
  • How do we regenerate icons without accidentally overwriting unrelated files?
  • Can we detect stale generated components in CI?
  • How should we handle malformed or potentially unsafe SVG input?
  • Can the same SVG catalog support multiple frameworks?
  • Can we automate regeneration without maintaining a separate workflow for every application?

At this point, SVG conversion stops being a simple file transformation.

It becomes an engineering workflow.

That's the problem SVGER-CLI aims to solve.


Introducing SVGER-CLI

SVGER-CLI is an open-source SVG-to-component generation tool with a dependency-light core, nine framework targets, and integrations for common JavaScript build systems.

The project is designed around a straightforward principle:

Keep the SVG processing workflow consistent, while allowing each frontend framework to receive code in its own native component format.

Instead of configuring a completely separate conversion tool for every framework, you use a common CLI and select the desired output target.

SVGER-CLI supports:

Framework target Typical generated format
React .tsx / .jsx
React Native .tsx / .jsx using native SVG primitives
Vue 3 .vue
Angular .component.ts
Svelte .svelte
Solid .tsx / .jsx
Preact .tsx / .jsx
Lit .ts / .js
Vanilla JavaScript/TypeScript .js / .ts

These are nine generation targets, not nine bundled frontend frameworks.

SVGER-CLI generates source code. Your application still provides the appropriate framework runtime, compiler, and build configuration.

For example, React Native consumers need a compatible SVG renderer such as react-native-svg, and Angular output requires TypeScript.

That distinction matters, especially in projects that maintain several component libraries from one shared asset catalog.

What Does "Zero Dependency" Actually Mean?

Let's clarify an important point.

SVGER-CLI's ordinary SVG-to-component generation path is designed without required third-party runtime dependencies for its core processing.

This is not the same as claiming that installing the package can never install another package.

The project has development dependencies for building and testing itself, and it declares optional packages for functionality such as image comparison.

For example, optional visual comparison uses packages including pixelmatch, pngjs, and a separately installed compatible version of sharp.

So the accurate statement is:

SVGER-CLI provides core SVG generation without required runtime dependencies, while keeping specialized functionality optional.

Why does that matter?

A smaller mandatory dependency surface can simplify installation, auditing, maintenance, and dependency management. But dependency count alone does not prove that a tool is faster or more secure.

Actual performance and security depend on implementation, input characteristics, runtime conditions, and testing.

The architecture is the advantage. The performance still needs to be measured.


Getting Started in 60 Seconds

SVGER-CLI's package declares support for Node.js >=18.17.0.

That is a compatibility floor, not a recommendation to run an end-of-life Node.js version in production. For new projects, use a maintained Node.js LTS release supported by your environment.

Install the version used throughout this article:

npm install --save-dev svger-cli@4.1.0
Enter fullscreen mode Exit fullscreen mode

Confirm the installed CLI:

npx --no-install svger-cli --version
Enter fullscreen mode Exit fullscreen mode

Inspect available commands:

npx --no-install svger-cli --help
Enter fullscreen mode Exit fullscreen mode

Now suppose your project contains:

my-project/
├── assets/
│   └── icons/
│       ├── home.svg
│       ├── search.svg
│       └── settings.svg
├── src/
│   └── components/
└── package.json
Enter fullscreen mode Exit fullscreen mode

Generate React TypeScript components:

npx svger-cli build \
  ./assets/icons \
  ./src/components/icons \
  --framework react \
  --typescript
Enter fullscreen mode Exit fullscreen mode

SVGER-CLI reads the SVG files and generates framework-specific components in the destination directory.

The exact filenames, exported symbols, and generated index files depend on your naming and output configuration.

For a single file, use generate instead:

npx svger-cli generate \
  ./assets/icons/home.svg \
  ./src/components/icons \
  --framework react \
  --typescript
Enter fullscreen mode Exit fullscreen mode

That's the basic workflow: source SVG, selected framework, generated component.

But there is considerably more to the project than conversion.


One SVG Catalog, Nine Framework Targets

The real benefit appears when several frontend applications share the same icon library.

You can generate different implementations from the same SVG directory.

React

svger build ./assets/icons ./generated/react \
  --framework react \
  --typescript
Enter fullscreen mode Exit fullscreen mode

Vue 3

svger build ./assets/icons ./generated/vue \
  --framework vue \
  --composition \
  --typescript
Enter fullscreen mode Exit fullscreen mode

The --composition option requests Vue's Composition API / <script setup> style.

Angular

svger build ./assets/icons ./generated/angular \
  --framework angular \
  --standalone \
  --typescript
Enter fullscreen mode Exit fullscreen mode

Angular generates TypeScript components. JavaScript output is intentionally unsupported for this target.

Svelte

svger build ./assets/icons ./generated/svelte \
  --framework svelte \
  --typescript
Enter fullscreen mode Exit fullscreen mode

React Native

svger build ./assets/icons ./generated/native \
  --framework react-native \
  --typescript
Enter fullscreen mode Exit fullscreen mode

React Native components target native SVG primitives rather than browser SVG elements.

Solid

svger build ./assets/icons ./generated/solid \
  --framework solid \
  --typescript
Enter fullscreen mode Exit fullscreen mode

Preact

svger build ./assets/icons ./generated/preact \
  --framework preact \
  --typescript
Enter fullscreen mode Exit fullscreen mode

Lit

svger build ./assets/icons ./generated/lit \
  --framework lit \
  --typescript
Enter fullscreen mode Exit fullscreen mode

Vanilla JavaScript

svger build ./assets/icons ./generated/vanilla \
  --framework vanilla \
  --no-typescript
Enter fullscreen mode Exit fullscreen mode

Now a monorepo can keep shared SVG source files in one place while generating components for several applications:

design-system/
├── assets/
│   └── icons/
│       ├── home.svg
│       ├── search.svg
│       └── settings.svg
│
├── packages/
│   ├── icons-react/
│   ├── icons-vue/
│   ├── icons-angular/
│   └── icons-svelte/
│
└── package.json
Enter fullscreen mode Exit fullscreen mode

Each package can have its own generation command, output folder, compilation checks, and release lifecycle.

The source of the icons remains consistent.

The generated implementation belongs to the target framework.

Important: Use separate output directories for different targets. Do not mix manually maintained components and generator-owned files in the same directory.


Beyond Conversion: What Makes SVGER-CLI Different?

SVG conversion is useful. Managing the resulting artifacts reliably is where a tool becomes more valuable in larger projects.

SVGER-CLI includes several capabilities aimed at that second problem.

1. Preview a Build Without Writing Files

Before regenerating hundreds of components, you may want to know what the command intends to do.

SVGER-CLI provides a dry-run mode:

svger build ./assets/icons ./generated/react \
  --framework react \
  --dry-run
Enter fullscreen mode Exit fullscreen mode

For automation, request a structured report:

svger build ./assets/icons ./generated/react \
  --framework react \
  --dry-run \
  --format json
Enter fullscreen mode Exit fullscreen mode

This is particularly useful when introducing a generator into an existing repository.

You can review the proposed work before committing changes.

2. Detect Stale Generated Components in CI

Generated components can drift from their SVG sources.

Someone changes an icon but forgets to regenerate the corresponding component. Another developer changes generator configuration without rebuilding the output.

SVGER-CLI includes a check mode:

svger build ./assets/icons ./generated/react \
  --framework react \
  --check
Enter fullscreen mode Exit fullscreen mode

The command fails when the generated artifacts do not match the expected output.

That makes it suitable for CI pipelines where generated files are committed to version control.

You can also inspect differences without writing:

svger build ./assets/icons ./generated/react \
  --framework react \
  --diff
Enter fullscreen mode Exit fullscreen mode

The distinction is simple:

Mode Purpose
Normal build Generate and write output
--dry-run Plan generation without committing files
--check Detect outdated output
--diff Report differences without writing

These are mutually exclusive build modes.

For engineering teams, this is more valuable than simply making component generation faster.

It makes generated code easier to verify.

3. Detect Naming Collisions Before Writing

Consider these SVG filenames:

home-icon.svg
HomeIcon.svg
Enter fullscreen mode Exit fullscreen mode

Depending on your naming rules, both might resolve to the same component name.

Without collision detection, a generator could accidentally overwrite one component with another.

SVGER-CLI supports collision policies and defaults to rejecting ambiguous output collisions.

You can make that explicit:

svger build ./assets/icons ./generated/react \
  --framework react \
  --collision error
Enter fullscreen mode Exit fullscreen mode

Alternative policies exist for cases where choosing a winner is intentional, but a strict error is a sensible default for shared design systems.

4. Recover From Interrupted Generation

A large generation operation can be interrupted.

A process crashes. A machine loses power. A filesystem operation fails partway through applying output changes.

SVGER-CLI includes transaction-oriented output handling and a recovery command:

svger recover ./generated/react --format json
Enter fullscreen mode Exit fullscreen mode

The recovery system is designed to use transaction journals and controlled rollback behavior rather than treating an interrupted build as an arbitrary filesystem state.

This does not mean every interruption is automatically recoverable under every operating system or failure condition.

Recovery relies on filesystem trust and permission assumptions, and platform-specific behavior should be validated before relying on it in production workflows.

Still, the underlying idea is important:

Output generation should consider failure recovery, not just successful execution.

5. Protect Selected Files

Sometimes an asset should not be changed through the normal managed workflow.

For example, a brand logo may require explicit review before modifications are allowed.

SVGER-CLI provides file-lock commands:

svger lock ./assets/icons/company-logo.svg
Enter fullscreen mode Exit fullscreen mode

And later:

svger unlock ./assets/icons/company-logo.svg
Enter fullscreen mode Exit fullscreen mode

These are managed workflow protections, not operating-system security locks.

They help teams express intent around assets that require special handling.

6. Watch Mode for Local Development

During active development, you may want components to regenerate as SVG files change.

Use the dedicated watch command:

svger watch ./assets/icons ./generated/react
Enter fullscreen mode Exit fullscreen mode

Watch mode observes source changes and triggers regeneration.

Framework and language preferences for watch workflows should be placed in the project configuration. Do not assume that every build flag is accepted by the watch command.


Security: SVG Files Are Not Always Harmless

An SVG is not merely a collection of vector paths.

It is an XML-based document format that can contain external resource references, styles, embedded content, and constructs that may be inappropriate for a source-code generation pipeline.

For an individual developer converting known assets, this may rarely become visible.

For a team processing files from designers, external packages, uploads, or third-party sources, the input boundary becomes more important.

SVGER-CLI's security model includes a bounded XML scanner before normal optimization and artifact generation.

By default, its unsafe-input policy is reject.

The validator rejects classes of input such as:

  • Malformed or unsupported XML structures.
  • DTD and entity declarations.
  • Event-handler attributes and active embedded elements.
  • Prohibited external resource references.
  • Disallowed CSS resource-loading constructs.
  • Inputs exceeding configured resource limits.

The scanner also enforces limits on document size, nesting, and structural complexity.

For example:

svger build ./assets/icons ./generated/react \
  --framework react \
  --unsafe-input-policy reject \
  --max-input-size 10485760
Enter fullscreen mode Exit fullscreen mode

The example sets a maximum input size of 10 MiB.

There is also an explicit strip mode for selected unsafe constructs:

svger build ./assets/icons ./generated/react \
  --framework react \
  --unsafe-input-policy strip
Enter fullscreen mode Exit fullscreen mode

However, strip mode is not a general-purpose SVG sanitizer.

It can remove content, change appearance, or reject unsupported XML altogether. It should not be used simply to bypass a security diagnostic.

Nor should the input scanner be described as a complete security certification for every SVG feature, browser, or rendering environment.

The useful guarantee is narrower: the generator applies a documented admission policy to the SVG subset it accepts.

For production systems, that's a much more meaningful engineering claim than simply saying that SVG inputs are safe.


Build Tool Integration: Beyond the CLI

One of the biggest improvements in the SVGER-CLI ecosystem is its integration surface.

The package provides dedicated entry points for:

  • Webpack
  • Vite
  • Rollup
  • Babel
  • Next.js
  • Jest

These integrations let teams move SVG generation into existing development and build workflows instead of maintaining separate manual commands.

Example: Vite + React

Install SVGER-CLI:

npm install --save-dev svger-cli@4.1.0
Enter fullscreen mode Exit fullscreen mode

Configure vite.config.mjs:

import { defineConfig } from 'vite';
import { svgerVitePlugin } from 'svger-cli/vite';

export default defineConfig({
  plugins: [
    svgerVitePlugin({
      source: './assets/icons',
      output: './src/generated/icons',
      framework: 'react',
      typescript: true,
      hmr: true,
      generateIndex: true,
    }),
  ],
});
Enter fullscreen mode Exit fullscreen mode

Now SVG component generation is part of the Vite-oriented workflow.

With index generation enabled, consumers may import from a generated barrel rather than referencing every component file individually.

Always inspect the actual exported names, since they depend on component naming and output configuration.

Other Integration Entry Points

The library provides explicit ESM package subpaths:

import { SvgerWebpackPlugin } from 'svger-cli/webpack';

import { svgerVitePlugin } from 'svger-cli/vite';

import { svgerRollupPlugin } from 'svger-cli/rollup';

import { svgerBabelPlugin } from 'svger-cli/babel';

import { withSvger } from 'svger-cli/nextjs';
Enter fullscreen mode Exit fullscreen mode

Jest-related entry points are available for SVG transformations and test mocks.

SVGER-CLI is published as an ES module package, so use its documented ESM integrations unless your particular toolchain has been tested with another loading arrangement.

For detailed configuration examples, see the integration documentation.


Configuration Without Repeating Every Option

Commands are useful for experimentation.

For a maintained project, configuration should be versioned alongside the source code.

SVGER-CLI uses .svgconfig.json.

Create one with:

svger config --init
Enter fullscreen mode Exit fullscreen mode

A possible React configuration is:

{
  "source": "./assets/icons",
  "output": "./src/generated/icons",
  "framework": "react",
  "typescript": true,
  "defaultWidth": 24,
  "defaultHeight": 24,
  "defaultFill": "currentColor",
  "unsafeInputPolicy": "reject",
  "maxInputSizeBytes": 10485760,
  "outputConfig": {
    "naming": "pascal"
  }
}
Enter fullscreen mode Exit fullscreen mode

This keeps important generation decisions visible in source control.

You can inspect the saved configuration:

svger config --show
Enter fullscreen mode Exit fullscreen mode

Or explain resolved values and their sources:

svger config --explain framework --format json
Enter fullscreen mode Exit fullscreen mode

SVGER-CLI resolves configuration using built-in defaults, project configuration, compiler options, and explicit build overrides.

For teams operating several applications, this makes configuration behavior easier to inspect and debug.


Optimization and Visual Correctness

SVG optimization deserves its own discussion.

Reducing source size is useful, but removing or rewriting SVG data can affect rendering.

An optimizer might change attributes, path representations, numeric precision, or structural details. Some changes are harmless; others depend on how the SVG is used.

SVGER-CLI provides standalone optimization:

svger optimize \
  ./assets/icons/home.svg \
  ./assets/optimized/home.svg \
  --level balanced
Enter fullscreen mode Exit fullscreen mode

Component generation also supports optimization levels:

svger build ./assets/icons ./generated/react \
  --framework react \
  --optimize basic
Enter fullscreen mode Exit fullscreen mode

Supported build optimization levels include none, basic, balanced, aggressive, and maximum.

These are configuration levels, not promises of a particular percentage reduction or guaranteed pixel-equivalent output.

It's important to validate optimized assets in the actual application.

Optional Visual Comparison

SVGER-CLI also has an optional raster-based comparison path.

It requires additional packages and a compatible Node.js runtime. In the v4.1 documentation, visual rasterization requires Node.js >=20.9.0 and sharp >=0.35.5, with pixelmatch and pngjs.

For a project using a compatible runtime:

npm install --save-dev sharp@^0.35.5 pixelmatch pngjs
Enter fullscreen mode Exit fullscreen mode

Visual validation can be requested through the documented optimizer path:

svger optimize \
  ./assets/icons/home.svg \
  ./assets/optimized/home.svg \
  --level balanced \
  --validate
Enter fullscreen mode Exit fullscreen mode

Visual comparison is a supplementary check. It is not a proof that all SVG semantics, accessibility behavior, or browser rendering characteristics are identical.

That distinction is especially relevant for sophisticated icons that use masks, filters, gradients, CSS, or other rendering features.


What About Performance?

The original version of this article compared SVGER-CLI, SVGR, and other SVG tools using a small table of execution times.

For an engineering tool, performance numbers should be reproducible rather than promotional.

A fair comparison needs to control variables such as:

  1. The exact version of each tool.
  2. The same SVG input corpus.
  3. Equivalent output requirements and optimization settings.
  4. Node.js and operating-system versions.
  5. Cold-start versus warm-process execution.
  6. Output correctness and framework compilation.
  7. Multiple benchmark iterations, reporting median and tail latency.

Install size, dependency count, and transformation speed are also separate measurements.

A tool with no required core runtime dependencies is not automatically the fastest converter. Likewise, a faster conversion isn't very useful if its generated output does not compile or faithfully represent the input.

A More Reproducible Approach

SVGER-CLI maintains a local evaluation workflow for comparing its production Svelte generation path with the opt-in experimental Svelte IR implementation.

From a development checkout, maintainers can run:

npm run build

npm run evaluate:local -- \
  --groups 50,750 \
  --warmups 8 \
  --samples 40 \
  --output ./evaluation.json
Enter fullscreen mode Exit fullscreen mode

The evaluator records information such as timing distributions, output digests, host metadata, and selected quality checks.

It is not an SVGR-versus-SVGER benchmark, and it should not be presented as one.

That's a useful direction for the project: publish measurements that other developers can inspect and reproduce, including unfavorable results.

Rather than claiming a universal speed advantage, I recommend benchmarking SVGER-CLI on the real SVG catalog and frameworks used by your team.


Experimental Features Should Stay Explicit

SVGER-CLI's default Svelte generation path uses its established legacy compiler.

The v4.1 source also documents an opt-in Svelte IR compiler for a bounded subset of static SVG input.

For example:

{
  "framework": "svelte",
  "typescript": false,
  "svelteCompiler": "ir-v1"
}
Enter fullscreen mode Exit fullscreen mode

This is an experimental compiler route rather than a replacement for the normal generation pipeline.

Unsupported constructs are rejected, and the project does not promise complete SVG semantic, accessibility, or browser-rendering equivalence.

The project's local evaluation has also shown cases where the opt-in IR compiler is slower than the legacy implementation.

That is precisely why opt-in experimentation and measured qualification are preferable to silently changing the default compiler.


A Practical CI Workflow

Let's connect everything into a realistic engineering workflow.

Suppose your React project stores icons in assets/icons and commits generated components under src/generated/icons.

A typical local workflow is:

# Generate components
svger build ./assets/icons ./src/generated/icons \
  --framework react \
  --typescript

# Review proposed changes without writing
svger build ./assets/icons ./src/generated/icons \
  --framework react \
  --typescript \
  --diff

# Verify generated output is current
svger build ./assets/icons ./src/generated/icons \
  --framework react \
  --typescript \
  --check
Enter fullscreen mode Exit fullscreen mode

Your CI pipeline can install dependencies from the committed lockfile:

npm ci
Enter fullscreen mode Exit fullscreen mode

Then run the same check command:

npx svger-cli build ./assets/icons ./src/generated/icons \
  --framework react \
  --typescript \
  --check
Enter fullscreen mode Exit fullscreen mode

A nonzero result for stale artifacts can fail the CI job.

You should also run your application's existing TypeScript checks, framework compiler, and tests.

This establishes a useful engineering contract:

SVG sources and generation configuration determine expected artifacts, and CI verifies that the committed output remains synchronized.

For multi-framework repositories, create a separate check for each generated target.


When Should You Use SVGER-CLI Instead of SVGR?

SVGR remains a useful choice for projects focused specifically on converting SVGs into React components.

SVGER-CLI is especially interesting when your needs extend beyond that.

Requirement What SVGER-CLI offers
Multiple frontend frameworks Nine generation targets under one CLI
React-only component conversion Supported, with other tools also viable
Shared icon catalogs Per-framework output directories
Build pipeline integration Webpack, Vite, Rollup, Babel, Next.js, Jest
Reproducible generated artifacts --check, --diff, --dry-run
Input admission controls Default unsafe-SVG rejection and resource bounds
Interrupted output handling Transaction-oriented output and recovery commands
Custom workflow behavior Configuration and plugin extension points
Core dependency management No required third-party runtime dependencies for normal generation

SVGER-CLI is not intended to eliminate every other SVG library.

It does not replace frontend runtimes, a complete browser rendering environment, general-purpose XML tooling, or every SVG transformation that may be available in specialized libraries.

Its value is in unifying and controlling the workflow that turns SVG assets into framework components.

For a small React-only application, another tool might be sufficient.

For a design system serving multiple applications, the broader workflow can be compelling.


A Few Limitations Worth Knowing

No developer tool should be described as universally suitable without discussing its boundaries.

Some important considerations for SVGER-CLI are:

Framework correctness: Generated code must still be compiled and tested against the target framework and its supported version.

SVG coverage: Security admission and compiler transformations operate on documented supported input. Not every valid SVG feature necessarily has equivalent behavior across every generated framework.

Platform recovery: Transaction recovery has filesystem permission and trust assumptions. Validate sensitive recovery workflows on your actual target operating systems.

TypeScript consumers: Some public declarations may require Node.js type definitions, depending on which APIs your application imports and how its TypeScript environment is configured.

Optional visual comparison: Rasterization requires extra packages and does not prove universal pixel or semantic equivalence.

Performance: The project should be judged through reproducible workloads, not unqualified claims about being several times faster than competing tools.

These limitations do not undermine the purpose of SVGER-CLI.

They define where more testing, documentation, and engineering work add value.


Who Is SVGER-CLI For?

I see particularly strong use cases in five environments.

Design systems: Maintain a shared icon catalog and generate compatible components for multiple frontend applications.

Monorepos: Keep framework-specific output packages synchronized with a single source asset directory.

Microfrontend architectures: Support teams working with React, Angular, Vue, and other frameworks without forcing identical component runtimes.

Component libraries: Generate and publish framework-specific icon packages with predictable naming, exports, and build checks.

Engineering teams with CI requirements: Detect stale artifacts, inspect diffs, apply input admission policies, and reduce manual regeneration mistakes.

If you're managing one SVG file in one application, the CLI can be convenient.

If you're managing hundreds of SVG files across multiple frameworks and contributors, the engineering workflow is where it becomes more interesting.


Try SVGER-CLI

Get started with the v4.1.0 package:

npm install --save-dev svger-cli@4.1.0
Enter fullscreen mode Exit fullscreen mode

Generate your first components:

npx svger-cli build \
  ./assets/icons \
  ./src/generated/icons \
  --framework react \
  --typescript
Enter fullscreen mode Exit fullscreen mode

Or choose a different framework:

npx svger-cli build \
  ./assets/icons \
  ./src/generated/vue \
  --framework vue \
  --composition \
  --typescript
Enter fullscreen mode Exit fullscreen mode

Explore the project:

The project is open source under the MIT license. Contributions, reproducible bug reports, compatibility feedback, and real-world benchmark results are welcome.


Final Thoughts

SVG conversion is easy to underestimate.

At first, the problem appears to be replacing an <svg> tag with a React component.

As a project grows, the real challenges are different: consistent generation, multiple framework targets, output naming, reproducibility, security boundaries, CI integration, and handling failures.

SVGER-CLI approaches those problems as parts of one workflow.

Its goal isn't simply to generate more component formats. It's to make SVG processing easier to maintain as engineering systems become more complex.

One SVG catalog. Nine framework targets. One consistent generation workflow.

That is the direction we're building toward with SVGER-CLI.

If you're working on a design system, monorepo, or multi-framework frontend platform, give it a try and share what works—and what still needs improvement.

Happy building! 🚀

Disclosure: I contribute to the SVGER-CLI project. This article describes its documented capabilities and known limitations rather than an independently verified performance comparison.

Top comments (2)

Collapse
 
kvetoslavnovak profile image
kvetoslavnovak • • Edited

This is very nice automation.

I was using quite a similar pattern in Svelte 5 like this. But manually, it was just about 10 icons. So no hassle.

<script>
    let {
        name,
        width = '1.5em',
        height = '1.5em',
        focusable = false,
        class: className = ''
    } = $props();

    let icons = {
        user: {
            svg: `<path fill="none" d="M0 0h24v24H0V0z"/><path d="M12 6c1.1 0 2 .9 2 2s-.9 2-2 2-2-.9-2-2 .9-2 2-2m0 10c2.7 0 5.8 1.29 6 2H6c.23-.72 3.31-2 6-2m0-12C9.79 4 8 5.79 8 8s1.79 4 4 4 4-1.79 4-4-1.79-4-4-4zm0 10c-2.67 0-8 1.34-8 4v2h16v-2c0-2.66-5.33-4-8-4z"/>`
        },
        ...
        }
        let displayIcon = icons[name];
</script>

<svg
    xmlns="http://www.w3.org/2000/svg"
    viewBox="0 0 24 24"
    fill="currentColor"
    class={className}
    {focusable}
    {width}
    {height}
>
    {@html displayIcon.svg}
</svg>

<style>
...
</style>
Enter fullscreen mode Exit fullscreen mode

Usage in component/page

<script>
    import Icon from './Icon.svelte';
</script>

<Icon name="user" class="contrast" width="2rem" height="2rem" />
Enter fullscreen mode Exit fullscreen mode
Collapse
 
navid_rezadoost_33d170b80 profile image
navid rezadoost •

Yes, I was involved in this challenge on a larger scale.
Thank you for sharing your experience.