Tailwind @Apply: Replacing Complex Classes with Tailwind CSS

What is Tailwind CSS?

Tailwind CSS is an open-source utility-based CSS framework that provides a set of customizable utilities for constructing web designs and layouts. It's one of the best CSS frameworks for responsive web design in 2024.

The key difference between Tailwind CSS framework and other CSS frameworks like Bootstrap and Material UI is that it does not contain a collection of preset classes for components such as buttons and tables. Instead, it includes extensive utility classes for grids, margins, forms, placement, and so forth.

Tailwind CSS automatically removes any extraneous CSS, resulting in the shortest CSS bundle possible when building for production.

How to Install Tailwind CSS into Your Project

The Tailwind CLI tool is the quickest and easiest way to embed Tailwind CSS into your project from scratch. Check that you have Node.js installed before you begin.

Step 1: Install Tailwind CSS into your project with the following command:

npm install -D tailwindcss

Save this code

Step 2: Then, create a tailwind.config.js file with this command:

npx tailwindcss init

Save this code

Step 3: In your tailwind.config.js file, add the paths to all of your template files like this:

/** @type {import('tailwindcss').Config} */
module.exports = {
  content: ["./src/**/*.{html,js}"],
  theme: {
    extend: {},
  },
  plugins: [],
}

Save this code

Step 4: Add the @tailwind directives to your main CSS file to represent each of Tailwind's layers.

@tailwind base;
@tailwind components;
@tailwind utilities;

Save this code

Step 5: Add your compiled CSS file to the of your markup file and begin styling your content with Tailwind's utility classes.

Save this code

To ensure you are setting up you Tailwind properly, you can watch this video to Install tailwind css from scratch using the CLI

Getting Started with Tailwind CSS @apply

Tailwind CSS’s @apply directive is a relatively new feature in the Tailwind CSS ecosystem that allows developers to “apply” existing utility classes in line with their custom CSS. It is convenient when you need to write custom CSS (for example, to override styles in a third-party library) but still want to work with your design tokens and use the same syntax as you would in HTML.

@tailwind base;
@tailwind components;
@tailwind utilities;
.class {
 background-color: blue;
 border-radius: 50%;
}
/* re-using the styling for the first class here */
.class-2 {
 @apply class;
}
/* applying Tailwind CSS utility classes */
.another__class {
 @apply border border=gray-300 rounded;
}

Save this code

How to Use the Tailwind @apply Directive in Your Next Project

@apply allows you to reuse preset utility classes to style several components in your application. You can also combine its functionalities with other front-end frameworks, such as Bootstrap.

Consider the code below:

 Button Success Button Danger Button

Save this code

In the code above, we created three buttons by using the @apply directive to import preset utility classes.

Here’s the result:

You may discover that the buttons share various utility classes. These utility classes can be used for the base styling of any variant of our buttons. Consider an application with 25 buttons. We must then write the common utility classes (used for base styling) 25 times. This can lead to maintenance issues, because updating the common utility classes requires you to do so in 25 different places throughout the app, which quickly becomes complex and redundant.

In such cases, you can use the @apply directive to convert standard utility classes into custom CSS classes. We can avoid duplicating the traditional utility classes this way.

We've extracted our utility classes into the btn class below:

Save this code

We now have the appropriate level of abstraction for our utility classes after grouping the utility classes into the btn class.

Note: To avoid specificity issues, you can use the @layer components directive to notify Tailwind which layer your custom component styles reside in. @layer allows you to control declaration order by automatically shifting your styles to the equivalent @tailwind directive, and it also allows you to use features like modifiers and tree-shaking in your own custom CSS. You can access this guide to get a better understanding of the @layer directive.

Using @apply with Tailwind CSS Components

Component frameworks like Svelte and Vue allow per-component styling within a <style> block in each component file. If you try to @apply a custom class defined in your global CSS to one of these per-component <style> blocks, you will encounter an error.

<style>
 @tailwind base;
 @tailwind components;
 @tailwind utilities;

 @layer components {
        .class {
            background-color: theme(colors.blue);
            border-radius: theme(borderRadius.lg);
            box-shadow: theme(boxShadow.xl);
        }
}

        div {
 /* Won't work because the styles are processed separately and individually */
 @apply class;
        }
    </style>

Save this code

The error appears because frameworks like Vue and Svelte process each <style> block independently and run your PostCSS plugin chain against each one in isolation. So, if you have 25 components, each with a <style> block, Tailwind will process the styles 25 times with no knowledge of the prior runs. As a result, when you try to @apply a predefined class from your global CSS, it fails, because Tailwind has no notion that the class exists as the styles are applied independently.

The solution to this problem is to use the plugin system in tailwind.config.js to define any custom styles you want to @apply in your components.

const plugin = require('tailwindcss/plugin')

module.exports = {
 // ...
  plugins: [
    plugin(function ({ addComponents, theme }) {
      addComponents({
 '.class': {
          backgroundColor: theme('colors.blue'),
          borderRadius: theme('borderRadius.lg'),
          boxShadow: theme('boxShadow.xl'),
        }
      })
    })
  ]
}

Save this code

Conclusion

This article discussed the Tailwind @apply CSS directive, emphasizing some of its capabilities, use cases, and modes of operation. Because it reduces repetition in your project code base and allows for easy maintenance, the @apply directive has shown to be a better alternative to using complex classes. Because of its simplicity and ease of application, this component can be applied to much larger real-world endeavors.

I hope this article is valuable to you.

Happy coding!