Create a JavaScript tab component with an adaptive stepper UI

In the past, I’ve shown you how to create different tabbed interfaces. Today, we’ll build another responsive JavaScript tab component where the clickable tabs will appear as a stepper component.

If you aren’t familiar with stepper components, their primary goal is to improve the user experience by organizing large logical content blocks into smaller sequential steps. A widespread use case of such a component is the creation of a multi-step checkout in eCommerce sites.

Our Tab Component

Here’s what we’re going to create—resize your browser to see how the tab layout changes:

<br />

We won’t focus so much on accessibility in this tutorial, so exploring how to make this component more accessible would be a valid next step.

1. Begin with the page markup

Inside a container, we’ll place two lists that include the tabs and their associated content (panels).

By default, the first tab will be active.

Here’s the required markup:

<div class="grid">
  <ul class="tab-list">
    <li class="active">
      <a href="">
        <span class="dot"></span>
        <span>...</span>
      </a>
    </li>
    <!-- more items here -->
  </ul>
  <ul class="tab-panels">
    <li class="active">...</li>
    <!-- more items here -->
  </ul>
</div>

Let’s concentrate on the main styles—you can see all of them by clicking on the CSS tab of the demo project.

On large screens (>700px), the tab component will be like this:

On smaller ones, it’ll look like this:

Notice how the stepper switches between horizontal and vertical orientation depending on the screen size.

Also, consider that all tab panels will be stacked and moved away 100% to the left; at any time, only the one with the active class will appear and sit in its initial position.

Here’s a part of the required styles:

/*CUSTOM VARIABLES HERE*/

.grid {
  display: grid;
  grid-template-columns: auto auto;
  gap: 70px;
  max-width: 1000px;
  padding: 0 20px;
  margin: 0 auto;
}

.tab-list li {
  display: flex;
}

.tab-list li:not(:last-child) {
  margin-bottom: 40px;
}

.tab-list a {
  display: inline-flex;
  align-items: center;
  gap: 24px;
  text-decoration: none;
}

.tab-list a .dot {
  position: relative;
  display: inline-block;
  width: 32px;
  height: 32px;
  border-radius: 50%;
  border: 1px solid var(--stepper-outline-color);
}

.tab-list li a .dot::before,
.tab-list li:not(:last-child) a .dot::after {
  content: "";
  position: absolute;
  left: 50%;
}

.tab-list li a .dot::before {
  top: 50%;
  transform: translate(-50%, -50%) scale(0);
  width: 18px;
  height: 18px;
  border-radius: 50%;
  background: var(--stepper-active-color);
  transition: transform 0.3s;
}

.tab-list li:not(:last-child) a .dot::after {
  top: calc(100% + 1px);
  transform: translateX(-50%);
  height: 40px;
  border-left: 2px dashed var(--stepper-connector-color);
}

.tab-list li.active a {
  font-weight: bold;
}

.tab-list li.active a .dot::before {
  transform: translate(-50%, -50%) scale(1);
}

.tab-panels {
  display: grid;
  overflow: hidden;
}

.tab-panels > li {
  grid-area: 1/1;
  opacity: 0;
  transform: translateX(-100%);
  transition: opacity 0.35s ease-in-out, transform 0.7s ease-in-out;
}

.tab-panels > li.active {
  opacity: 1;
  transform: none;
}

@media (max-width: 700px) {
  .grid {
    grid-template-columns: 1fr;
    gap: 30px;
  }

  .tab-list {
    display: flex;
    justify-content: center;
  }

  .tab-list li:not(:last-child) {
    margin: 0 40px 0 0;
  }

  .tab-list li a span:last-child {
    display: none;
  }

  .tab-list a {
    gap: 0;
  }

  .tab-list li:not(:last-child) a .dot::after {
    top: 50%;
    left: calc(100% + 1px);
    transform: translateY(-50%);
    width: 40px;
    height: auto;
    border-bottom: 2px dashed var(--stepper-connector-color);
    border-left: 0;
  }
}

3. Add the JavaScript

Each time we click on a tab link, we’ll remove the active class from the currently active tab and panel. Then, we’ll put that class in the tab and panel associated with that link.

Here’s the required JavaScript:

const tabList = document.querySelector(".tab-list");
const tabItems = tabList.querySelectorAll("li");
const tabLinks = tabList.querySelectorAll("a");
const tabPanelsList = document.querySelector(".tab-panels");
const tabPanels = tabPanelsList.querySelectorAll("li");
const ACTIVE_CLASS = "active";

for (const tabLink of tabLinks) {
  tabLink.addEventListener("click", function (e) {
    e.preventDefault();
    tabList.querySelector(`li.${ACTIVE_CLASS}`).classList.remove(ACTIVE_CLASS);
    tabPanelsList
      .querySelector(`li.${ACTIVE_CLASS}`)
      .classList.remove(ACTIVE_CLASS);

    const parent = tabLink.parentElement;
    let parentIndex = Array.from(tabItems).indexOf(parent);
    parent.classList.add(ACTIVE_CLASS);
    tabPanelsList
      .querySelector(`li:nth-child(${++parentIndex})`)
      .classList.add(ACTIVE_CLASS);
  });
}

Add keyboard support

Although our component isn’t optimized for accessibility, let’s add support for keyboard navigation.

On small screens, each time the left (←) or right (→) arrow keys are pressed, we’ll grab the currently active tab. From there, we’ll check to see which arrow is clicked. If that’s the right arrow, we’ll set the next active tab as the one that immediately follows the current active tab. If there isn’t such a tab, the next tab becomes the first one. Similarly, if the left arrow is clicked, we’ll set the next tab as the one that immediately precedes the currently active tab. If there isn’t such a tab, the next tab becomes the last one.

We’ll follow the same process with the up (↑) and down (↓) keys on large screens.

Here’s the relevant JavaScript code:

...

tabList.addEventListener("keyup", function (e) {
  const activeTabListItem = tabList.querySelector(`li.${ACTIVE_CLASS}`);

  if (
    e.key === "ArrowUp" ||
    e.key === "ArrowDown" ||
    e.key === "ArrowLeft" ||
    e.key === "ArrowRight"
  ) {
    if (
      (mqSm.matches && (e.key === "ArrowUp" || e.key === "ArrowDown")) ||
      (mqLg.matches && (e.key === "ArrowLeft" || e.key === "ArrowRight"))
    ) {
      return;
    }

    if (e.key === "ArrowUp" || e.key === "ArrowLeft") {
      const prevActiveTabListItem = activeTabListItem.previousElementSibling
        ? activeTabListItem.previousElementSibling
        : lastTabListItem;
      prevActiveTabListItem.querySelector("a").click();
    } else {
      const nextActiveTabListItem = activeTabListItem.nextElementSibling
        ? activeTabListItem.nextElementSibling
        : firstTabListItem;
      nextActiveTabListItem.querySelector("a").click();
    }
  }
});

Conclusion

Congrats, folks! We built this beautiful and unique responsive JavaScript tab component without writing much code. From there, you can use it as it is and make it more accessible by checking the code of a similar component like Bootstrap’s tabs.

Alternatively, you can isolate the tab list layout that looks like a stepper component and use it as you wish by adding functionality for navigation arrows, etc.

Before closing, let’s recall what we created today: