What is a modal? And how to build a CSS-only Modal

CSS has come a long way from its humble beginnings of basic styling. Thanks to the use of pseudo-classes, we’re now able to style elements based on certain behaviour. In this tutorial, we’ll be using the :target pseudo-class to build a modal element.

What is a modal?

A modal is an element displayed on top of other elements on a webpage, preventing interaction with the rest of the webpage until the modal is dismissed. Modals are usually used to display information pertinent to the user or call attention to a required action.

Since modals require user interaction to be displayed or dismissed, they are commonly built using JavaScript. There’s even an inbuilt JavaScript API specifically for handling modals without needing to write any JavaScript code.

In this tutorial, however, we’ll be looking at how to build modals without the use of any JavaScript at all. Instead, we’ll build our fully functional modal CSS component.

The :target CSS pseudo-class represents a unique element (the target element) with an id matching the URL’s fragment. – MDN

We’ll be building a modal that

opens when a button is clicked and

closes when the area outside the modal or the close button is clicked.

So we’ll need the following elements:

An element to control opening the modal

A modal container element to hold the modal content

A modal overlay to handle when outside the modal element is clicked

A close button to handle closing the modal element

To handle opening the modal class, we’ll set the modal id in the URL fragment using an anchor element. Anchor elements can link to a certain section of a webpage by using a # and then the element id.

When the anchor tag sets a URL fragment, the page URL looks like this:

When using fragments, the window location history is changed as well. This means if a user is on and they press the back button on their browser, they will be redirected to which is the same webpage.

The fragment is what the CSS :target pseudo-class uses to apply styling to the element with matching id. Once the modal id is set as the URL fragment, then we can use :target to display the modal element.

By that same logic, if we change the id in the URL fragment to something else, the :target styling will no longer be applied to the modal. We’ll set our close button and modal overlay elements to be anchor tags that reset the URL fragment, removing the target styling from the modal and hiding it in the process.

To close the modal, we can either set the href of our overlay and close button anchor elements to a blank fragment e.g. href=”#”, set it to another section id, or use an id that doesn’t exist #blank.

The benefit to using a blank fragment is that the URL will not contain unnecessary text but it will cause the page to scroll to the top when the modal is closed.

The benefit to using another section id is that we can decide what element gets focus when the modal section is closed but it may cause a slight page jump as the element will be scrolled into view.

The benefit to using an id that doesn’t exist is that the page will maintain the same scroll position as when the modal is closed but the fragment text will be displayed in the URL for some browsers and may look a bit out-of-place.

The HTML layout for our modal looks like this:

We’ve used the following attributes to handle accessible labelling for our modals:

role="dialog": This tells assistive technology that the element is a modal

aria-labelledby="modal-title": This provides a title for the modal container, by using the text in the ‘modal-title’ element

aria-label="Close modal": This provides descriptive text for the close modal button

tabindex="-1": This prevents the modal overlay from gaining focus when using a keyboard. This is because the overlay serves as a mainly visual cue and not a necessary function.

Once we have our layout set up, we can apply some basic styling to the anchor tags and modal elements. We want the anchor tag to look like a button and the modal element to be placed on top of other elements with a semi-transparent background for the modal overlay.

.modal-btn {
  transition: background 250ms;
  padding: 16px 24px;
  border-radius: 4px;
  background-color: #0f0f0f;
  color: #fcfcfc;
  text-transform: uppercase;
  font-size: 12px;
  letter-spacing: 0.1em;
  margin-top: 32px;
  display: inline-block;
  text-decoration: none;
}

.modal-btn:hover,
.modal-btn:focus {
  background-color: #0f0f0fdd;
}

.modal {
  position: fixed;
  min-height: 100vh;
  width: 100%;
  top: 0;
  left: 0;
  display: flex;
  z-index: 2;
}

.modal-overlay {
  width: 100%;
  height: 100%;
  position: absolute;
  background-color: rgba(0, 0, 0, 0.5);
  left: 0;
}

.modal-content {
  transition: transform 1s;
  background: #fff;
  width: 75%;
  position: relative;
  margin: auto;
  height: 75%;
  padding: 48px 24px;
  border-radius: 4px;
  max-width: 1000px;
}

.modal-close {
  font-size: 36px;
  text-decoration: none;
  color: inherit;
  position: absolute;
  right: 24px;
  top: 10px;
}

This is what our modal looks like so far:

We have our modal styled to be displayed by default so we just need to use the CSS :not pseudo-class to hide the modal if it’s not the target element.

1	.modal:not(:target) {
2	display: none;
3	}

That’s all we need to handle displaying and hiding the modal element based on which anchor tag is clicked but there are still more features to be considered.

Since we’re working with CSS, we can also apply transitions and animations to provide a smoother modal entry and exit. This is an example of the modal CSS with a fade and slide animation:

<br />

The CSS code looks like this:

.modal:not(:target) {
  visibility: hidden;
  transition-delay: 500ms;
  transition-property: visibility;
}

.modal:target .modal-content {
  transform: translateY(100vh);
  animation: 500ms ease-in-out slideUp forwards;
}

.modal:not(:target) .modal-content {
  transform: translateY(0);
  animation: 500ms ease-out slideDown forwards;
}

.modal:target .modal-overlay {
  opacity: 0;
  animation: 500ms linear fadeIn forwards;
}

@keyframes fadeOut {
  from {
    opacity: 1;
  }

  to {
    opacity: 0;
  }
}

@keyframes fadeIn {
  from {
    opacity: 0;
  }

  to {
    opacity: 1;
  }
}

@keyframes slideUp {
  from {
    transform: translateY(100vh);
  }

  to {
    transform: translateY(0);
  }
}

@keyframes slideDown {
  from {
    transform: translateY(0);
  }

  to {
    transform: translateY(100vh);
  }
}

We’ll delay the visibility transition of the modal to allow the exit animations to be completed before it’s completely hidden.

When building a modal element with any technology, there are some accessibility requirements that need to be put in place:

The modal should gain focus once opened and shift focus back to the main page when closed.

The modal content should be made visible to screen readers, only when open.

The modal can be closed with the keyboard.

Thanks to the way the URL fragment works, our modal automatically gains focus when the anchor tag is clicked. This is because URL fragments scroll to the section with the matching id which causes the focus to be shifted as well.

Regarding shifting focus back to the main page, the focus will be set back on the main page if the href=”#” attribute is used on the close button and overlay.

Alternatively, we can set the focus back to a specific element, such as the modal button, by using the element id. This method is preferred as it allows the user to maintain the same focus state they were in before opening the modal.

We’re going to need some JavaScript

For the rest of the features, however, we’re not able to take advantage of native behaviour so we’ll need to use some JavaScript to handle the accessibility requirements.

We’ll write a script to toggle the aria-hidden attribute for the modal and also include an event listener to allow the modal be closed when the Escape key is pressed.

Since we’re using the URL fragment to handle toggling the modal display, we can also use the same method in JavaScript with the popstate event listener.

This event listener detects when the window URL is changed. Then we can get the value of the URL fragment using the window.location.hash value. This is what our JavaScript code looks like:

const modal = document.getElementById('modal')

window.addEventListener('popstate', () => {
  if (window.location.hash === '#modal') {
    modal.focus();
    modal.setAttribute('aria-hidden', false);
    return
  }
  
  modal.setAttribute('aria-hidden', true)
});

We also use the keydown event listener to detect if the escape key is pressed and the modal is open. If it is, then we’ll close the modal by setting the window.location.hash value to empty

window.addEventListener('keydown', (e) => {
  if (e.key == "Escape" && window.location.hash === '#modal') {
    window.location.hash = ""
  }
})

This article on Accessible modal dialogs also provides more information on how to improve accessibility of modals.

Final result

And with that, we’ve built a functional modal component using CSS (and some JavaScript for accessibility).

<br />

Source link

Hosting Discounts

cloudways Discount
August 21, 2022
Hostinger Discount
August 21, 2022
DreamHost Discount
August 31, 2020