When creating a component-based, front-end infrastructure, one of the biggest pain points I’ve personally encountered is making components that are both reusable and responsive when there are nested components within components.

Take the following “call to action” (<CTA />) component, for example:

On smaller devices we want it to look like this:

This is simple enough with basic media queries. If we’re using flexbox, a media query can change the flex direction and makes the button go the full width. But we run into a problem when we start nesting other components in there. For example, say we’re using a component for the button and it already has a prop that makes it full-width. We are actually duplicating the button’s styling when applying a media query to the parent component. The nested button is already capable of handling it!

This is a small example and it wouldn’t be that bad of a problem, but for other scenarios it could cause a lot of duplicated code to replicate the styling. What if in the future we wanted to change something about how full-width buttons are styled? We’d need to go through and change it in all these different places. We should be able to change it in the button component and have that update everywhere.

Wouldn’t it be nice if we could move away from media queries and have more control of the styling? We should be using a component’s existing props and be able to pass different values based on the screen width.

Well, I have a way to do that and will show you how I did it.

I am aware that container queries can solve a lot of these issues, but it’s still in early days and doesn’t solve the issue with passing a variety of props based on screen width.

Tracking the window width

First, we need to track the current width of the page and set a breakpoint. This can be done with any front-end framework, but I’m using a Vue composable here as to demonstrate the idea:

// composables/useBreakpoints.js import { readonly, ref } from "vue"; const bps = ref({ xs: 0, sm: 1, md: 2, lg: 3, xl: 4 })
const currentBreakpoint = ref(bps.xl); export default () => { const updateBreakpoint = () => { const windowWidth = window.innerWidth; if(windowWidth >= 1200) { currentBreakpoint.value = bps.xl } else if(windowWidth >= 992) { currentBreakpoint.value = bps.lg } else if(windowWidth >= 768) { currentBreakpoint.value = bps.md } else if(windowWidth >= 576) { currentBreakpoint.value = bps.sm } else { currentBreakpoint.value = bps.xs } } return { currentBreakpoint: readonly(currentBreakpoint), bps: readonly(bps), updateBreakpoint, };
};

The reason we are using numbers for the currentBreakpoint object will become clear later.

Now we can listen for window resize events and update the current breakpoint using the composable in the main App.vue file:

// App.vue <script>
import useBreakpoints from "@/composables/useBreakpoints";
import { onMounted, onUnmounted } from 'vue' export default { name: 'App', setup() { const { updateBreakpoint } = useBreakpoints() onMounted(() => { updateBreakpoint(); window.addEventListener('resize', updateBreakpoint) }) onUnmounted(() => { window.removeEventListener('resize', updateBreakpoint) }) }
}
</script>

We probably want this to be debounced, but I’m keeping things simple for brevity.

Styling components

We can update the <CTA /> component to accept a new prop for how it should be styled:

// CTA.vue
props: { displayMode: { type: String, default: "default" }
}

The naming here is totally arbitrary. You can use whatever names you’d like for each of the component modes.

We can then use this prop to change the mode based on the current breakpoint:

<CTA :display-mode="currentBreakpoint > bps.md ? 'default' : 'compact'" />

You can see now why we’re using a number to represent the current breakpoint — it’s so the correct mode can be applied to all breakpoints below or above a certain number.

We can then use this in the CTA component to style according to the mode passed through:

// components/CTA.vue <template> <div class="cta" :class="displayMode"> <div class="cta-content"> <h5>title</h5> <p>description</p> </div> <Btn :block="displayMode === 'compact'">Continue</Btn> </div>
</template> <script>
import Btn from "@/components/ui/Btn";
export default { name: "CTA", components: { Btn }, props: { displayMode: { type: String, default: "default" }, }
}
</script> <style scoped lang="scss">
.cta { display: flex; align-items: center; .cta-content { margin-right: 2rem; } &.compact { flex-direction: column; .cta-content { margin-right: 0; margin-bottom: 2rem; } }
}
</style>

Already, we have removed the need for media queries! You can see this in action on a demo page I created.

Admittedly, this may seem like a lengthy process for something so simple. But when applied to multiple components, this approach can massively improve the consistency and stability of the UI while reducing the total amount of code we need to write. This way of using JavaScript and CSS classes to control the responsive styling also has another benefit…

Extensible functionality for nested components

There have been scenarios where I’ve needed to revert back to a previous breakpoint for a component. For example, if it takes up 50% of the screen, I want it displayed in the small mode. But at a certain screen size, it becomes full-width. In other words, the mode should change one way or the other when there’s a resize event.

Showing three versions of a call-to-action components with nested components within it.

I’ve also been in situations where the same component is used in different modes on different pages. This isn’t something that frameworks like Bootstrap and Tailwind can do, and using media queries to pull it off would be a nightmare. (You can still use those frameworks using this technique, just without the need for the responsive classes they provide.)

We could use a media query that only applies to middle sized screens, but this doesn’t solve the issue with varying props based on screen width. Thankfully, the approach we’re covering can solve that. We can modify the previous code to allow for a custom mode per breakpoint by passing it through an array, with the first item in the array being the smallest screen size.

<CTA :custom-mode="['compact', 'default', 'compact']" />

First, let’s update the props that the <CTA /> component can accept:

props: { displayMode: { type: String, default: "default" }, customMode: { type: [Boolean, Array], default: false },
}

We can then add the following to generate to correct mode:

import { computed } from "vue";
import useBreakpoints from "@/composables/useBreakpoints"; // ... setup(props) { const { currentBreakpoint } = useBreakpoints() const mode = computed(() => { if(props.customMode) { return props.customMode[currentBreakpoint.value] ?? props.displayMode } return props.displayMode }) return { mode }
},

This is taking the mode from the array based on the current breakpoint, and defaults to the displayMode if one isn’t found. Then we can use mode instead to style the component.

Extraction for reusability

Many of these methods can be extracted into additional composables and mixins that can be reuseD with other components.

Extracting computed mode

The logic for returning the correct mode can be extracted into a composable:

// composables/useResponsive.js import { computed } from "vue";
import useBreakpoints from "@/composables/useBreakpoints"; export const useResponsive = (props) => { const { currentBreakpoint } = useBreakpoints() const mode = computed(() => { if(props.customMode) { return props.customMode[currentBreakpoint.value] ?? props.displayMode } return props.displayMode }) return { mode }
}

Extracting props

In Vue 2, we could repeat props was by using mixins, but there are noticeable drawbacks. Vue 3 allows us to merge these with other props using the same composable. There’s a small caveat with this, as IDEs seem unable to recognize props for autocompletion using this method. If this is too annoying, you can use a mixin instead.

Optionally, we can also pass custom validation to make sure we’re using the modes only available to each component, where the first value passed through to the validator is the default.

// composables/useResponsive.js // ... export const withResponsiveProps = (validation, props) => { return { displayMode: { type: String, default: validation[0], validator: function (value) { return validation.indexOf(value) !== -1 } }, customMode: { type: [Boolean, Array], default: false, validator: function (value) { return value ? value.every(mode => validation.includes(mode)) : true } }, ...props }
}

Now let’s move the logic out and import these instead:

// components/CTA.vue import Btn from "@/components/ui/Btn";
import { useResponsive, withResponsiveProps } from "@/composables/useResponsive"; export default { name: "CTA", components: { Btn }, props: withResponsiveProps(['default 'compact'], { extraPropExample: { type: String, }, }), setup(props) { const { mode } = useResponsive(props) return { mode } }
}

Conclusion

Creating a design system of reusable and responsive components is challenging and prone to inconsistencies. Plus, we saw how easy it is to wind up with a load of duplicated code. There’s a fine balance when it comes to creating components that not only work in many contexts, but play well with other components when they’re combined.

I’m sure you’ve come across this sort of situation in your own work. Using these methods can reduce the problem and hopefully make the UI more stable, reusable, maintainable, and easy to use.

Similar Posts