Streamline Your JSX: The Comment-Based Attribute Plugin for Vite

Overview

If you've ever worked with modern JavaScript frameworks like React or Solid, you know the pain of scanning through JSX laden with long attribute lists—especially class names. A single element can easily sport a dozen utility classes, turning a readable template into a wall of text. This not only slows down visual parsing but also makes comparison between component variants tedious.

Streamline Your JSX: The Comment-Based Attribute Plugin for Vite — Source: dev.to

Enter a lightweight Vite plugin that moves heavy JSX attributes—by default, className or class—into comments placed directly above the element. The result: cleaner, shorter JSX that's easier to scan, while still preserving all style information. Even better, it enables a quick prototyping workflow: you can temporarily override the commented-out attribute by adding it directly on the element, letting you test new values without touching the original comment.

In this guide, you'll learn how to install, configure, and use this plugin in your own Vite projects. We'll walk through real examples, point out common pitfalls, and give you everything you need to start writing cleaner, more maintainable JSX today.

Prerequisites

Before diving in, ensure you have the following:

Node.js (version 14 or higher) installed on your system.
npm or yarn as your package manager.
A Vite project using React, Solid, or any framework that renders JSX/TSX. If you don't have one, create it with npm create vite@latest my-app -- --template react (or solid).
Basic familiarity with JSX syntax and Vite configuration.

Step-by-Step Instructions

1. Install the Plugin

Open your terminal and navigate to your Vite project root. Install the plugin from npm:

npm install vite-plugin-jsx-comment-attributes --save-dev

Or if you prefer Yarn:

yarn add -D vite-plugin-jsx-comment-attributes

2. Configure Vite to Use the Plugin

Edit your vite.config.js (or vite.config.ts) file. Import the plugin and add it to the plugins array:

import { defineConfig } from 'vite';
import react from '@vitejs/plugin-react';
import jsxCommentAttributes from 'vite-plugin-jsx-comment-attributes';

export default defineConfig({
  plugins: [
    react(),
    jsxCommentAttributes()
  ]
});

By default, the plugin targets className (for React) and class (for Solid). If you need to customize which attributes to move, pass options—see the Configuration Options section.

3. Restart Your Dev Server

After saving the config, stop your current dev server (Ctrl+C) and start it again with npm run dev (or yarn dev). The plugin will now transform your JSX files on the fly.

4. See It in Action: Before and After

Consider the original JSX snippet:

<h1 className="rounded-lg bg-blue-500 px-4 py-2 text-white">Hello Mom</h1>

After the plugin processes this file, it becomes:

{/* @class rounded-lg bg-blue-500 */}
{/* @class px-4 py-2 text-white */}
<h1>Hello Mom</h1>

The long class string is split into two comment lines, each prefixed with @class. The element itself now has no className attribute—its styles are derived entirely from the comments above.

Note: The plugin does not remove the actual CSS; it merely moves the attribute value into a comment. The comment is then interpreted by the runtime (if you use a special processor) or simply ignored by the browser. This is purely a developer experience tool—use it during development, and rely on your build process to include the original CSS elsewhere.

5. Prototyping with Inline Overrides

One of the most powerful features is the ability to test new attribute values without modifying the comment. Write a temporary className on the element:

{/* @class rounded-lg bg-blue-500 */}
<h1 className="title">Hello Mom</h1>

Here, the class comment is ignored (since an inline attribute exists), and the element renders with className="title". This lets you quickly experiment with different styles—just remove the inline attribute to revert to the comment-driven version.

Configuration Options (Optional)

If you need to move a different attribute (e.g., style, data-*), pass options to the plugin. Example:

jsxCommentAttributes({
  attributes: ['className', 'style'],
  commentPrefix: '@attr' // default is '@class'
})

This would move both className and style into comments prefixed with @attr. You can also define a custom parser for advanced scenarios.

Common Mistakes

Forgetting to install the plugin as a dev dependency. The plugin only runs during build/dev; it doesn't belong in production dependencies. Use --save-dev or -D.
Not restarting the dev server after adding the plugin. Vite caches config changes, so you must restart to load the plugin.
Using the wrong comment syntax. The plugin expects {/* ... */} comments in JSX. If your editor auto-formats to something else (e.g., //), it won't be recognized.
Conflicts with ESLint or Prettier. Some linters may flag commented-out attributes as dead code. Disable rules like no-unused-expressions for comment directives, or add an ignore statement.
Assuming the plugin removes the CSS file. It doesn't. You still need to import your CSS separately. The comment is just a visual placeholder.
Mixing inline attributes with comments on the same element. As shown above, an inline attribute overrides the comment, but only one set can be active. If you add an inline className while keeping the comment, only the inline is used—the comment is ignored.

Summary

This small but mighty Vite plugin transforms your JSX development experience by moving heavy attributes into clean, readable comments. You gain shorter templates, faster visual scanning, and a handy prototyping mechanism—all with minimal setup. Try it in your next project, and let the community know what additional directives you'd find useful. The project is open source and welcomes contributions on GitHub.

Tags: