DEV Community: Jason Beggs

Building a modal with Vue.js and Tailwind CSS

Jason Beggs — Tue, 03 Nov 2020 13:21:26 +0000

Modal windows are a popular UI component and are useful for many different scenarios. You might use one for alerting a user, showing a form, or even popping up a login form. The uses are limitless.

In this tutorial, we'll walk through how to build a reusable card modal using Vue.js and Tailwind CSS. The component will use Vue.js slots, so you can change the contents of the modal wherever it is used while retaining the open/close functionality and the wrapper design.

We'll be starting with a brand-new Laravel 5.8 project. The only additional setup we need to perform is setting up Tailwind, but I won't be going into detail on how to setup Vue and Tailwind in this tutorial.

Getting started with the modal

To begin, let's create a CardModal Vue component and register it in the resources/js/app.js file.

// resources/assets/js/components/CardModal.vue
<template>
  <div>
    The modal will go here.
  </div>
</template>

<script>
export default {
  //
}
</script>

// resources/js/app.js
Vue.component('card-modal', require('./components/CardModal.vue').default);

const app = new Vue({
  el: '#app',
});

To start using the component, we need to update the resources/views/welcome.blade.php view to the following. Note the .relative class on the body tag.

<!DOCTYPE html>
<html lang="{{ str_replace('_', '-', app()->getLocale()) }}">
<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">

    <title>{{ config('app.name', 'Laravel') }}</title>

    <script src="{{ asset('js/app.js') }}" defer></script>
    <link href="{{ asset('css/app.css') }}" rel="stylesheet">
</head>
<body class="relative font-sans p-8">
    <div id="app">
        <h1 class="font-bold text-2xl text-gray-900">Example Project</h1>
        <p class="mb-6">This is just a example text for my tutorial.</p>

        <card-modal></card-modal>
    </div>
</body>
</html>

Making the modal appear

Right now, the text inside the modal will always show. Let's start by making the component accept a prop to show or hide the contents.

Update the component to accept a showing prop and add a v-if directive to the div in the template to show/hide the contents when the showing prop changes.

<template>
  <div v-if="showing">
    The modal will go here.
  </div>
</template>

<script>
export default {
  props: {
    showing: {
      required: true,
      type: Boolean
    }
  }
}
</script>

We'll also need to add a data property to our Vue instance so we can show or hide the modal from outside the CardModal component. We'll default the property to false so the modal will be hidden when the page loads.

const app = new Vue({
  el: '#app',
  data: {
    exampleModalShowing: false,
  },
});

Then, we need to pass the exampleModalShowing prop to the CardModal in our welcome view. We'll also need a button to show the modal.

<div id="app">
    <h1 class="font-bold text-2xl text-gray-900 ">Example Project</h1>
    <p class="mb-6">This is just a example text for my tutorial.</p>

    <button
      class="bg-blue-600 text-white px-4 py-2 text-sm uppercase tracking-wide font-bold rounded-lg"
      @click="exampleModalShowing = true"
    >
      Show Modal
    </button>
    <card-modal :showing="exampleModalShowing"></card-modal>
</div>

Styling the modal

Next, let's add some styling to the modal. We'll need a card surrounding the contents and a semi-transparent background around the card. The background will also need to be position fixed so it can take up the full screen without moving any of the other contents on the page. Let's start by adding the background and centering the contents. For the transparent background, we will need to add a semi-75 color to our Tailwind configuration.

<template>
  <div
    v-if="showing"
    class="fixed inset-0 w-full h-screen flex items-center justify-center bg-semi-75"
  >
    The modal will go here.
  </div>
</template>

To add the semi-75 color so the bg-semi-75 class works, we will extend the colors configuration in our tailwind.config.js file.

module.exports = {
  theme: {
    extend: {
      colors: {
        'bg-semi-75': 'rgba(0, 0, 0, 0.75)'
      }
    }
  }
};

Now, we need to set a max width, background color, shadow, rounded edges, and padding for the card. We'll add a div to wrap the content inside the modal and add these classes to it.

<div
  v-if="showing"
  class="fixed inset-0 w-full h-screen flex items-center justify-center bg-semi-75"
>
  <div class="w-full max-w-2xl bg-white shadow-lg rounded-lg p-8">
    The modal will go here.
  </div>
</div>

Using slots for the content

Now that we have the basic styling finished, let's update the component to use a slot so the content of the modal can be configured where the component is used instead of inside the component. This will make the component much more reusable.

First, we need to replace the content inside the component with a <slot>. If you're not familiar with Vue.js slots, essentially, they allow you to pass html into a component and it will be rendered wherever you specify the <slot> tags.

<div
  v-if="showing"
  class="fixed inset-0 w-full h-screen flex items-center justify-center bg-semi-75"
>
  <div class="w-full max-w-2xl bg-white shadow-lg rounded-lg p-8">
    <slot />
  </div>
</div>

Second, in the welcome view, we just place the html we want to show inside the modal between the <card-modal> and </card-modal> tags.

<card-modal :showing="exampleModalShowing">
    <h2>Example modal</h2>
    <p>This is example text passed through to the modal via a slot.</p>
</card-modal>

Closing the modal

The component is getting close to finished, but we have one little problem. We haven't made a way to close the modal yet. I'd like to add a few different ways to close the modal. First, we'll add a simple close x at the top right of the card. We need to add a button to the template that calls a close method inside the component. Be sure to add the .relative class to the card div.

<template>
  <div
    v-if="showing"
    class="fixed inset-0 w-full h-screen flex items-center justify-center bg-semi-75"
  >
    <div class="relative w-full max-w-2xl bg-white shadow-lg rounded-lg p-8">
      <button
        aria-label="close"
        class="absolute top-0 right-0 text-xl text-gray-500 my-2 mx-4"
        @click.prevent="close"
      >
        &times;
      </button>
      <slot />
    </div>
  </div>
</template>

<script>
export default {
  props: {
    showing: {
      required: true,
      type: Boolean
    }
  },
  methods: {
    close() {
      this.$emit('close');
    }
  }
};
</script>

You'll see that the close method emits a close event. We'll need to listen for the event outside the component and update the exampleModalShowing property to false. In the welcome view, we can listen for the event by adding a @close listener on the <card-modal> tag.

<card-modal :showing="exampleModalShowing" @close="exampleModalShowing = false">
    <h2 class="text-xl font-bold text-gray-900">Example modal</h2>
    <p>This is example text passed through to the modal via a slot.</p>
</card-modal>

To close the modal from outside the component, we can add a button that sets exampleModalShowing to false as well.

<card-modal :showing="exampleModalShowing" @close="exampleModalShowing = false">
    <h2 class="text-xl font-bold text-gray-900">Example modal</h2>
    <p class="mb-6">This is example text passed through to the modal via a slot.</p>
    <button
      class="bg-blue-600 text-white px-4 py-2 text-sm uppercase tracking-wide font-bold rounded-lg"
      @click="exampleModalShowing = false"
    >
      Close
    </button>
</card-modal>

Now when we click the "Show Modal" button, the modal should appear. When we click the close button or the x inside the modal, the modal should disappear.

I'd also like the modal to close when the background behind the card is clicked. Using Vue.js, it's pretty easy to add that functionality. We can just add @click.self="close" to the background div and Vue will handle the rest. The .self modifier will make it so the listener is only triggered when the background itself is clicked. Without that modifier, the modal would close whenever anything inside the card is clicked as well, which is not what we want.

<template>
  <div
    v-if="showing"
    class="fixed inset-0 w-full h-screen flex items-center justify-center bg-semi-75"
    @click.self="close"
  >
    <div class="relative w-full max-w-2xl bg-white shadow-lg rounded-lg p-8">
      <button
        aria-label="close"
        class="absolute top-0 right-0 text-xl text-gray-500 my-2 mx-4"
        @click.prevent="close"
      >
        &times;
      </button>
      <slot />
    </div>
  </div>
</template>

Adding a transition

To make the component feel smoother, let's wrap the component in a transition so the modal fades in. Once again, Vue makes this pretty easy with <Transition> components. We just need to wrap the background div in a <Transition> tag and add a few CSS classes to the bottom of the component.

<template>
  <Transition name="fade">
    <div
      v-if="showing"
      class="fixed inset-0 w-full h-screen flex items-center justify-center bg-semi-75"
      @click.self="close"
    >
      <div class="relative w-full max-w-2xl bg-white shadow-lg rounded-lg p-8">
        <button
          aria-label="close"
          class="absolute top-0 right-0 text-xl text-gray-500 my-2 mx-4"
          @click.prevent="close"
        >
          &times;
        </button>
        <slot />
      </div>
    </div>
  </Transition>
</template>

// script...

<style scoped>
.fade-enter-active,
.fade-leave-active {
  transition: all 0.4s;
}
.fade-enter,
.fade-leave-to {
  opacity: 0;
}
</style>

Fixing scroll issues

Overall, the component is working pretty well. We can open/close the modal, it fades in nicely, and is really reusable. If you add the component to a page with a lot of content though, you might notice one issue. While the modal is open, if you try to scroll the page, the background is allowed to scroll. This is usually not desirable, so I'll show you how to fix that issue. We can add a Vue watcher to the showing prop. When the showing prop is set to true, we need to add overflow: hidden to the body element of our page. When it is set to false, we need to remove that style. We can use the .overflow-hidden class provided by Tailwind.

<script>
export default {
  props: {
    showing: {
      required: true,
      type: Boolean
    }
  },
  watch: {
    showing(value) {
      if (value) {
        return document.querySelector('body').classList.add('overflow-hidden');
      }

      document.querySelector('body').classList.remove('overflow-hidden');
    }
  },
  methods: {
    close() {
      this.$emit('close');
    }
  }
};
</script>

Conclusion

Now that our component is complete, you're free to use it as you wish, in multiple places with different content in each place. It's a really useful component for showing small forms, getting user confirmations, and other use cases. I'd love to hear how you end up using the component!

This component is based on some principles taught in Adam Wathan's "Advanced Vue Component Design" course and simplified/modified for my needs. If you're interested in learning more about this subject and other advanced Vue.js practices, I would highly recommend checking out his course!

Building a flash message component with Vue.js

Jason Beggs — Tue, 27 Oct 2020 12:19:28 +0000

In this tutorial, I am going to walk through how to build a custom flash message component using Vue.js and Tailwind CSS. I'll be building it inside a brand-new Laravel 5.8 project, but you can adapt it for use in any project running Vue.js and Tailwind CSS.

The component we build will have a "danger" theme and a "success" theme. You can choose to extend it with a "warning" theme or any other themes you see fit.

Prerequisites

This is an intermediate tutorial, so I am not going to cover the basics of Vue.js and Tailwind CSS or how to set them up in your project. I will assume you have already done that following their documentation. I have also removed all the boilerplate JavaScript in the resources/js/app.js file except the following:

window.Vue = require('vue');

const app = new Vue({
  el: '#app',
});

In my routes/web.php file, I am starting with:

<?php

Route::view('/', 'welcome');

In my welcome view (resources/views/welcome.blade.php), I am starting with:

<!DOCTYPE html>
<html lang="{{ str_replace('_', '-', app()->getLocale()) }}">
<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">

    <title>{{ config('app.name', 'Laravel') }}</title>

    <script src="{{ asset('js/app.js') }}" defer></script>
    <link href="{{ asset('css/app.css') }}" rel="stylesheet">
</head>
<body>
    <div id="app">
        <h1 class="font-bold">Example Project</h1>
    </div>
</body>
</html>

Let's get started

To get started, let's create our flash-message component and register it in our resources/js/app.js file.

window.Vue = require('vue');

Vue.component('flash-message', require('./components/FlashMessage.vue').default);

const app = new Vue({
  el: '#app',
});

Next, we need to include the component in our welcome view, so it will show up on the page. I usually insert it near the bottom of the #app div. We will want this component mounted on any page that might use it.

<div id="app">
    <h1 class="font-bold">Example Project</h1>

    <flash-message></flash-message>
</div>

Styling the component

Let's get some basic styling done using TailwindCSS. While styling the component, I will just use a static message and our "danger" theme, but later these will be variable options. The following markup will place the component in the top right of the screen, add a close icon in the top right of the component, and provide some decent styling.

<template>
  <div class="fixed top-0 right-0 m-6">
    <div
      class="bg-red-200 text-red-900 rounded-lg shadow-md p-6 pr-10"
      style="min-width: 240px"
    >
      <button
        class="opacity-75 cursor-pointer absolute top-0 right-0 py-2 px-3 hover:opacity-100"
      >
        &times;
      </button>
      <div class="flex items-center">
        Oops! Something terrible happened...
      </div>
    </div>
  </div>
</template>

Making the classes and text dynamic

If you replace the bg-red-200 text-red-900 classes with bg-green-200 text-green-900, you'll see our basic "success" styling. Let's make the classes and message text change based on a message property on our component. We'll need to add the following to the bottom of the component:

<template>
  <div class="fixed top-0 right-0 m-6">
    <div
      :class="{
        'bg-red-200 text-red-900': message.type === 'error',
        'bg-green-200 text-green-900': message.type === 'success',
      }"
      class="rounded-lg shadow-md p-6 pr-10"
      style="min-width: 240px"
    >
      <button
        class="opacity-75 cursor-pointer absolute top-0 right-0 py-2 px-3 hover:opacity-100"
      >
        &times;
      </button>
      <div class="flex items-center">
        {{ message.text }}
      </div>
    </div>
  </div>
</template>

<script>
export default {
  data() {
    return {
      message: {
        text: 'Hey! Something awesome happened.',
        type: 'success',
      },
    };
  },
};
</script>

Communicating with the component

Now, I'd like to find a way to set the message from outside the component. I think a simple Vue event bus will work great for this purpose. To set that up, we need to update our resources/js/app.js file to the following:

window.Vue = require('vue');
window.Bus = new Vue();

Vue.component('flash-message', require('./components/FlashMessage.vue').default);

const app = new Vue({
  el: '#app',
});

You may have used custom events in your Vue components before. We will be using a similar syntax to emit and listen to events on a global level: Bus.$emit('flash-message') and Bus.$on('flash-message'). Now that we have the event bus set up, let's make the component conditionally render based on the message property. We can do that by adding a v-if to the flash-message and setting the default message property to null.

<template>
  <div class="fixed top-0 right-0 m-6">
    <div
      v-if="message"
      :class="{
        'bg-red-200 text-red-900': message.type === 'error',
        'bg-green-200 text-green-900': message.type === 'success',
      }"
      class="rounded-lg shadow-md p-6 pr-10"
      style="min-width: 240px"
    >
      <button
        class="opacity-75 cursor-pointer absolute top-0 right-0 py-2 px-3 hover:opacity-100"
      >
        &times;
      </button>
      <div class="flex items-center">
        {{ message.text }}
      </div>
    </div>
  </div>
</template>

<script>
export default {
  data() {
    return {
      message: null,
    };
  },
};
</script>

When you load the page, you shouldn't see anything. Just for an example, let's add a trigger-form component that we can use to demonstrate how to send events with different options to the flash-message component. Start by creating the component at resources/js/TriggerForm.vue and registering it in the resources/js/app.js file and adding the component to the welcome view.

// ...
Vue.component('flash-message', require('./components/FlashMessage.vue').default);
Vue.component('trigger-form', require('./components/TriggerForm.vue').default);
//...

<div id="app">
    <h1 class="font-bold">Example Project</h1>

    <trigger-form></trigger-form>
    <flash-message></flash-message>
</div>

Inside the form component, we will need to add inputs, a button, and data properties to bind the inputs to.

<template>
  <form class="max-w-md" @submit.prevent="sendMessage">
    <label
      for="message-text"
      class="block mb-1 text-gray-700 text-sm"
    >
      Message Text
    </label>
    <input
      id="message-text"
      v-model="message.text"
      type="text"
      class="input mb-3"
    />
    <label
      for="message-type"
      class="block mb-1 text-gray-700 text-sm"
    >
      Message Type
    </label>
    <select id="message-type" v-model="message.type" class="input mb-3">
      <option value="success">
        Success
      </option>
      <option value="error">
        Error
      </option>
    </select>
    <button class="btn btn-blue">
      Send Message
    </button>
  </form>
</template>

<script>
export default {
  data() {
    return {
      message: {
        text: 'Hey! Something awesome happened.',
        type: 'success'
      }
    };
  },
  methods: {
    sendMessage() {
      // ...
    }
  }
};
</script>

Inside the sendMessage method, we will need to use the event bus to emit an event that the flash-message component listens to. When emitting an event from a Vue component, the first argument is the name of the event, and the second argument is any data the event listener will need. Here, we will pass ‘flash-message’ as the event name and this.message as the second argument. We will also reset the message after emitting the event.

sendMessage() {
  Bus.$emit('flash-message', this.message);

  this.message = {
    text: null,
    type: 'success',
  }
}

Inside our flash-message component, we need to set up a listener for this event and a callback to handle it. Let's start by adding a mounted method. Initially, all we need to do is set the message inside the component equal to the message that was passed with the event.

mounted() {
  Bus.$on('flash-message', (message) => {
    this.message = message;
  });
}

Now when we submit the form, the message component should appear with the text and theme we selected in the form.

Making the component disappear

To make our close button work, we just need to add an event handler to the button.

<button
  class="opacity-75 cursor-pointer absolute top-0 right-0 py-2 px-3 hover:opacity-100"
  @click.prevent="message = null"
>

Next, we'll make the component automatically disappear after a few seconds. We can accomplish this pretty easily using the setTimeout function.

After we handle setting the message in our mounted function, we can use setTimeout to clear the message after 5 seconds. If you want yours to disappear faster or slower, you can change that value.

mounted() {
  Bus.$on('flash-message', (message) => {
    this.message = message;

    setTimeout(() => {
      this.message = null;
    }, 5000);
  });
}

Initially, this solution may seem like it works fine, but if you submit the form twice within 5 seconds, the message will still disappear 5 seconds from when the first event was triggered. To solve that, we need to save the timer that's returned from the call to setTimeout and make sure to reset it when the next event comes in. We can easily do that by updating our code to the following.

mounted() {
  let timer;
  Bus.$on('flash-message', (message) => {
    clearTimeout(timer);

    this.message = message;

    timer = setTimeout(() => {
      this.message = null;
    }, 5000);
  });
}

Transitioning the component in and out

Next, we will use Vue's <Transition> component to slide the component in and out. First, we need to add a <style> tag to the bottom of the component. We'll add the CSS classes necessary for the transitions there.

<style scoped>
.slide-fade-enter-active,
.slide-fade-leave-active {
  transition: all 0.4s;
}
.slide-fade-enter,
.slide-fade-leave-to {
  transform: translateX(400px);
  opacity: 0;
}
</style>

Inside our template, we need to wrap the flash-message in a Transition element and pass it a name.

<template>
  <div class="fixed top-0 right-0 m-6">
    <Transition name="slide-fade">
      <div
        v-if="message"
        :class="{
          'bg-red-200 text-red-900': message.type === 'error',
          'bg-green-200 text-green-900': message.type === 'success'
        }"
        class="rounded-lg shadow-md p-6 pr-10"
        style="min-width: 240px"
      >
        <button class="opacity-75 cursor-pointer absolute top-0 right-0 py-2 px-3 hover:opacity-100">
          &times;
        </button>
        <div class="flex items-center">
          {{ message.text }}
        </div>
      </div>
    </Transition>
  </div>
</template>

In conclusion

If you'd like to add additional options like a message.delay property that specifies when the message will be cleared, feel free to do so. I'd love to see the different ways you take this example and make it better.

To view the full source code including the CSS for the form components, go here.