VueJS

Getting started with Vitepress

Published Dec 21, 2023

Updated Dec 29, 2023

12 min read

Getting started with Vitepress to create your blog site

Have you heard about Vitepress, but you have not checked it out at it yet? Well, in this article, we are going to cover the basic setup and share what all the fuss about this new fantastic static site generator.

If you are looking for something that would allow you to quickly create a static site with Markdown support, search, Light/Dark theme, advertisement, navigation, and much more, then Vitepress is what you are looking for.

Suppose you want some proof of Vitepress's power without having to invest any further time, I suggest you head over to the main Vitepress site (vitepress.dev) and experience what Vitepress can do, as the official site is built on Vitepress!

What is Vitepress

Vitepress is a powerful Static Site Generator powered by Vite mainly used for Documentation and Blogs with the default theme, and open to customization to be used for anything you may need it to with custom themes and theme overrides.. Vitepress power comes from its low learning curve, powerful configuration settings, and the ability to easily customize it.

For example, internationalization is built-in, Theme toggling is built-in and even full-site searches require a single line in the config to be set up.

What makes Vitepress so powerful is its extensive configuration and the fact that it can be customized by overriding the existing theme, creating your theme, or simply enhancing pages with custom Vue code.

Prerequisites

To successfully run the following demo, you will need:

Node.js version 18 or higher.
Terminal for accessing VitePress via its command line interface (CLI).
Text Editor with Markdown syntax support.
VSCode is recommended, along with the official Vue extension.

Create your project

To create the project, we will follow the steps shown in the official Getting Started guide.

If you want to set up a Vitepress project quickly, run the following steps:

Create a new folder mkdir vitepress-tutorial
Access the folder cd vitepress-tutorial
Install Vitepress npm add -D vitepress
Run the Wizard npx vitepress init
Answer the questions:
- Where should VitePress initialize the config?
- Site title
- Site Description
- Theme
- Do you want Typescript support?
run npm run docs:dev
Enjoy your site.

After you run the above steps, your Vitepress will be ready and running as shown below

What is available out of the box

The site comes fully set up with enough to get you started. Let's see what features are available within the software:

Navbar: The site comes with a Navbar that already includes links to our blog pages
Light/Dark theme: Out of the box theming
Home page: Basic Homepage layout
Blogs: Two different blog posts with sidebar navigation

All of the above is available with just 4 files! Let's move forward and see how to customize our app.

Overriding the homepage

It is time to modify our site by accessing its folders. What you will probably notice when opening the site, is that Vitepress follows a very simple file structure, in fact, a new installation just includes 4 extra files on top of the expected package.json and node_modules.

Let's update our homepage to make it more unique. Because Vitepress follows a "file-system based router" we can find this file within the root of the project within a file called index.md. This file will be accessible at "/" or "/index.html" of your site.

The content of the file is the following:

---
# https://vitepress.dev/reference/default-theme-home-page
layout: home

hero:
 name: "Vitepress tutorial"
 text: "A VitePress Site"
 tagline: My great project tagline
 actions:
   - theme: brand
     text: Markdown Examples
     link: /markdown-examples
   - theme: alt
     text: API Examples
     link: /api-examples

features:
 - title: Feature A
   details: Lorem ipsum dolor sit amet, consectetur adipiscing elit
 - title: Feature B
   details: Lorem ipsum dolor sit amet, consectetur adipiscing elit
 - title: Feature C
   details: Lorem ipsum dolor sit amet, consectetur adipiscing elit
---

As you can see, the file has no code in it, and it is just driven by configuration, or more specifically in this case Markdown frontmatter, that is a set of configurations accepted by markdown files that help you set up your options such as title, description, og:image. We will describe frontmatter in more detail later in the article.

Before we jump into modifying the configuration of the file, you should know that Vitepress has a very extensive and well-detailed documentation site where you can find help if you are stuck or would like to learn more. In this case, we are overriding the "home" page, so the documentation can be found here: Home Page Default Theme configuration.

If you read the current file within the homepage, you will notice that it defines a "layout" of "home". This layout displays a main header with CTAs and a set of feature blocks.

There are three different layouts available in the Default theme: "home", "doc" and "page".

The title and description have already been set from the information we provided from the installation wizard. But the rest is just a basic boiler template. Let's see what we can change:

Add a hero image. This image can either be externally sourced or saved within the repository.

hero:
 name: "Vitepress tutorial"
 text: "A VitePress Site"
 tagline: My great project tagline
 image:
   src: 'assets/logo.png'
   alt: 'My logo'

Update the action buttons.

 actions:
   - theme: brand
     text: First Blog
     link: /first
   - theme: alt
     text: Thisdot.co
     link: https://thisdot.co

As shown above, Action buttons have two themes "brand" or "alt" and can accept internal or external links.

Vitepress is clever enough to set the external links to open in a new tab and set the rel="noreferrer".

Change the feature blocks:

Features blocks are great for engaging with the user and telling them what makes your site special. This accepts an icon and some text, so let's change ours with the following:

features:
 - icon: 🏚️
   title: Your Documentation house
   details: This is the house of your documentation
 - icon:
     src: https://emojipedia.org/house
   title: This is the logo
   details: Nothing else to say

The homepage is now completed and updated and it should look like this: Vitepress homepage with redesign

Please note that what we did on the homepage is just changing the markdown front matter of the "home" layout. What this means is that if you want to, you can easily customise the page further by either adding more blocks to the layout file or actually by writing and styling the rest of the page as normal.

Site configuration

In this step, we are going learn about the main site configuration and how we can use it to customize our site.

The configuration file can be found in the .vitepress folder under the name of "config.mjs".

Just like the homepage layout, the configuration used in the preset file is self-explanatory:

import { defineConfig } from 'vitepress'

// https://vitepress.dev/reference/site-config
export default defineConfig({
 title: "Vitepress tutorial",
 description: "A VitePress Site",
 themeConfig: {
   // https://vitepress.dev/reference/default-theme-config
   nav: [
     { text: 'Home', link: '/' },
     { text: 'Examples', link: '/markdown-examples' }
   ],

   sidebar: [
     {
       text: 'Examples',
       items: [
         { text: 'Markdown Examples', link: '/markdown-examples' },
         { text: 'Runtime API Examples', link: '/api-examples' }
       ]
     }
   ],

   socialLinks: [
     { icon: 'github', link: 'https://github.com/vuejs/vitepress' }
   ]
 }
})

This file is very important and you are probably going to have it open at all times as it is going to be responsible for the layout of the sidebar navigations of your site.

In this section, we are going to learn how to use the Vitepress configuration file to achieve the following:

Modify the sidebar navigation
Enable Search
Add Favicon to your site

The sidebar is the component displayed on the left-hand side of the blog pages. This is not automatically generated, but it is manually set in this file.

You can have more than one navigation, so, for example, you could specify sidebar navigation that shows in pages that have "/blog/" within their path and another one for all markdown pages that have "/tutorials/".

Let's see how to implement this:

{
   sidebar: {
     '/blog/': [
       {
         text: 'Blog',
         items: [
           { text: 'Index', link: '/blog/' },
           { text: 'One', link: '/blog/one' }
         ]
       }
     ],

     '/tutorials/': [
       {
         text: 'Tutorial',
         items: [
           { text: 'Index', link: '/tutorials/' },
           { text: 'Two', link: '/tutorials/two' }
         ]
       }
     ]
   },
}

With the above code, there will be 2 different sidebars. One will just show if the URL includes "/blog" and the other will be displayed if the path includes "tutorials".

Clicking on the above items will give a 404 error as we do not have any pages in that specific location. Still, we can easily fix the issue by creating the two folders "blog" and "tutorial" and creating the required files within these folders in our case are "index.md" and "one.md" for the blog and "index.md" and "two.md" for tutorials.

The sidebar has further settings like the ability to create a nested tree or create collapsable menus. You can learn more by checking out the the official documentation on default theme sidebar.

Enable Search

No documentation or blog site is complete until a search is fully implemented on it. Luckily for us, enabling a site-wide search is extremely simple with Vitepress.

Vitepress supports two different search types: a full-text search using minisearch and Algolia based search.

In this tutorial, we are going to enable the full-text search. This is fully built-in and requires no external accounts.

To enable search, we need to add a "Search" parameter within our themeConfig and set the provider to "local". We can add this right below the socialLinks.

   socialLinks: [
     { icon: 'github', link: 'https://github.com/vuejs/vitepress' }
   ],
   search: {
     provider: 'local'
   }
 }

With just a simple config change, our site will now have a full site search working as shown below: Full site search of Vitepress

The official search documentation has further information about the look and functionality of the search.

Add Favicon to your site

Even if the site configuration is very extensive, there are times when you will need to add something within the site-wise page that is not available.

In this section we are going to learn how to add specific attributes to the <head> of our site, and specifically how to add a favicon.

To add custom values to the head, we are going to use the "head" properties available with the Vitepress configuration.

The "head" configuration is an array that accepts an array with the element type (eg. link, script, meta), and an object including all the attributes for that specific element.

So for example to replicate the following HTML:

<link rel="icon" href="/image/favicon.ico"/>

we would define the following head config:

 head: [
   [ 'link', { rel: 'icon', href: '/images/favicon.ico' } ],
 ]

We can use this technique to set up metadata and even load fonts or Google Analytics. More info in the site-config head

Writing your post

In the last section of this article, we are going to learn how to actually write a blog post and also learn how to customize the pages with JS and styles.

Writing your first page

In the previous section, we created a couple of markdown files, but they are currently empty. Let's see how to create beautiful documentation using the built-in feature of Vitepress.

In this section, we are going to work on the file stored in /blog/index.md. This file can be accessed in your browser by accessing "http://localhost:5174/blog/index.html".

Blog Frontmatter

Every file needs to have a frontmatter defined. This is used to define basic information on the page, such as the title, description, and more.

For best SEO results, it is best practice to always define a title and description for a new page. We can do this by adding the following code at the top of our file:

---
title: My Blog post title
description: My unique description
---

Frontmatter in Markdown files are delimited by the "---". In the above code, we set our title and description.

Vitepress frontmatter supports further config like lastUpdates, sidebar, outline, and more. You can find info on the frontmatter-config documentation.

Frontmatter has some global configuration, such as title and description, but also "layout specific" settings that are just available on specific layouts. This is clearly explained in the documentation.

Blog Markdown

Now that our post frontmatter is set, it is time to write the content of it. This is done using a very extensive markdown engine.

Let's start with the basics and write a heading with some text and a link as shown below:

## My heading one

My text

[link](thisdot.co)

After saving, our development environment will show the following results:

Let's add a couple of headings and a table of contents to our document using [[toc]] to the top of our page:

My Table of Contents:
[[toc]]

## first heading
My text

[link](thisdot.co)

### inner heading 3

## second heading
My text

[link](thisdot.co)

The above will produce an unordered list with all our links. Table of content

The last feature that I want to share about the Vitepress markdown engine is the code editors. The markdown engine used in Vitepress offers extensive features when it comes to code rendering.

Features available are "code highlight", "code focus", external snippets loading and much more. The full list of features can be found in the markdown docs.

Let's implement a simple code snippet with a line of code focused. This can be achieved by adding "// [!code focus]" at the end of our row. Let's give it a try:

const myNewFunction = () => {
   externalApi();
   const newCode = true; // [!code focus]
   return newCode;
}

The output of this will be:

Customize your blog with Vue

In this last section, we will learn how to customize our code by adding js logic, style, and external components.

Before we begin, it is important to understand that when you use the default template of Vitepress, your pages are going to be rendered with Vue.

This means that we can expand the individual page's functionality by rendering other vue components and/or writing logic and styles directly on the page.

To better explain this concept, we are going to create a team page. Create a file called team.md within the root of our repository.

This file will be accessible on "http://localhost:5174/team.html" and will be just a simple Markdown file.

First, we set up the frontmatter as before. In this case, we have to specify an additional config called "layout". This will ensure the page has no style or components loaded such as sidebar or aside.

---
layout: page
title: My team page
---

Then we will have to create our team variable, just like a normal Vue component; we can do so by defining a script setup tag and defining the constant there.

<script setup>
import {
 VPTeamMembers
} from 'vitepress/theme'

const members = [
 {
   avatar: 'assets/logo.png',
   name: 'Simone',
   title: 'Software Architect',
   links: [
     { icon: 'github', link: 'https://github.com/#' },
     { icon: 'Twitter', link: 'https://twitter.com/#' }
   ]
 },
 {
   avatar: 'assets/logo.png',
   name: "This Dot",
   title: "Software Company"
 }
]
</script>

In the above code, we have imported the VPTeamMembers component from the vitepress/theme and defined an array of members. The values used in the members array are hardcoded, but as you may expect, you can load this information directly from an API.

We now have to use the "members" variable within our file. We can do so by writing normal JavaScript. The markdown file will evaluate the JavaScript and render it, so in the following example it will render a specific component.

## Our Team

Say hello to our awesome team.
<VPTeamMembers size="small" :members="members" />

Before we move forward we need to define some style as the page is unstyled since we have loaded the layout of "page".

Just like we did with the <script> tag, we can load a <style> tag and update our styles:

<style>
h1 {
   color: red;
}
h1, p {
   text-align: center;
}
</style>

The completed file will look like this:

---
layout: page
title: My team page
---
<script setup>
import {
 VPTeamPage,
 VPTeamPageTitle,
 VPTeamMembers
} from 'vitepress/theme'

const members = [
 {
   avatar: 'assets/logo.png',
   name: 'Simone',
   title: 'Software Architect',
   links: [
     { icon: 'github', link: 'https://github.com/#' },
     { icon: 'Twitter', link: 'https://twitter.com/#' }
   ]
 },
 {
   avatar: 'assets/logo.png',
   name: "This Dot",
   title: "Software Company"
 }
]
</script>

<style>
h2 {
   color: red;
}
h2, p {
   text-align: center;
}
</style>
## Our Team

Say hello to our awesome team.

<VPTeamMembers size="small" :members="members" />

The file above now includes:

A frontmatter that specifies a "page" layout
A script tag that loads an external component and defines a variable
Styles to make the page pretty
Markdown with a custom component

The completed team page would render the following: Customised Theme page in Vitepress

Conclusion

Vitepress is an extremely flexible static site generator. Its default theme provides you with everything you need to get started quickly. The ability to load external themes, enhance the current theme, and or write custom code within your page makes this tool extremely powerful.

In future articles, we will discover what components are available within the Default Theme and see how you can make the most of your Vitepress site but keep on coding.

This Dot is a consultancy dedicated to guiding companies through their modernization and digital transformation journeys. Specializing in replatforming, modernizing, and launching new initiatives, we stand out by taking true ownership of your engineering projects.

We love helping teams with projects that have missed their deadlines or helping keep your strategic digital initiatives on course. Check out our case studies and our clients that trust us with their engineering.

About the author(s)

Simone Cuomo
Software Architect, Mentor, Speaker and Writer. Passionate about all aspect of web development, with a special love for VueJs
@zelig880 @zelig880

Understanding Vue.js's <Suspense> and Async Components

In this blog post, we will delve into how and async components work, their benefits, and practical implementation strategies to make your Vue.js applications more efficient and user-friendly. Without further ado, let’s get started! Suspense Let's kick off by explaining what Suspense components are. They are a new component that helps manage how your application handles components that need to await for some async resource to resolve, like fetching data from a server, waiting for images to load, or any other task that might take some time to complete before they can be properly rendered. Imagine you're building a web page that needs to load data from a server, and you have 2 components that fetch the data you need as they will show different things. Typically, you might see a loading spinner or a skeleton while the data is being fetched. Suspense components make it easier to handle these scenarios. Instead of manually managing loading states and error messages for each component that needs to fetch data, Suspense components let you wrap all these components together. Inside this wrapper, you can define: 1. What to show while the data is loading (like a loading spinner). 2. The actual content that should be displayed once the data is successfully fetched. This way, Vue Suspense simplifies the process of handling asynchronous operations (like data fetching) and improves the user (and the developer) experience by providing a more seamless and integrated way to show loading states and handle errors. There are two types of async dependencies that can wait on: - Components with an async setup() hook. This includes components using with top-level await expressions. *Note: These can only be used within a component.* - Async Components. Async components Vue's asynchronous components are like a smart loading system for your web app. Imagine your app as a big puzzle. Normally, you'd put together all the pieces at once, which can take time. But what if some pieces aren't needed right away? Asynchronous components help with this. Here's how they work: - Load Only What's Needed: Just like only picking up puzzle pieces you need right now, asynchronous components let your app load only the parts that are immediately necessary. Other parts can be loaded later, as needed. - Faster Start: Your app starts up faster because it doesn't have to load everything at once. It's like quickly starting with the border of a puzzle and filling in the rest later. - Save Resources: It uses your web resources (like internet data) more wisely, only grabbing what’s essential when it's essential. In short, asynchronous components make your app quicker to start and more efficient, improving the overall experience for your users. Example: ` Combining Async Components and Suspense Let's explore how combining asynchronous components with Vue's Suspense feature can enhance your application. When asynchronous components are used with Vue's Suspense, they form a powerful combination. The key point is that async components are "suspensable" by default. This means they can be easily integrated with Suspense to improve how your app handles loading and rendering components. When used together, you can do the following things: - Centralized Loading and Error Handling: With Suspense, you don't have to handle loading and error states individually for each async component. Instead, you can define a single loading indicator or error message within the Suspense component. This unified approach simplifies your code and ensures consistency across different parts of your app. - Flexible and Clean Code Structure: By combining async components with Suspense, your code becomes more organized and easier to maintain. An asynchronous component has the flexibility to operate independently of Suspense's oversight. By setting suspensible: false in its options, the component takes charge of its own loading behavior. This means that instead of relying on Suspense to manage when it appears, the component itself dictates its loading state and presentation. This option is particularly useful for components that have specific loading logic or visuals they need to maintain, separate from the broader Suspense-driven loading strategy in the application. In practice, this combo allows you to create a user interface that feels responsive and cohesive. Users see a well-timed loading indicator while the necessary components are being fetched, and if something goes wrong, a single, well-crafted error message is displayed. It's like ensuring that the entire puzzle is either revealed in its completed form or not at all rather than showing disjointed parts at different times. How it works When a component inside the boundary is waiting for something asynchronous, shows fallback content. This fallback content can be anything you choose, such as a loading spinner or a message indicating that data is being loaded. Example Usage Let’s use a simple example: In the visual example provided, imagine we have two Vue components: one showcasing a selected Pokémon, Eevee, and a carousel showcasing a variety of other Pokémon. Both components are designed to fetch data asynchronously. Without , while the data is being fetched, we would typically see two separate loading indicators: one for the Eevee Pokemon that is selected and another for the carousel. This can make the page look disjointed and be a less-than-ideal user experience. We could display a single, cohesive loading indicator by wrapping both components inside a boundary. This unified loading state would persist until all the data for both components—the single Pokémon display and the carousel—has been fetched and is ready to be rendered. Here's how you might structure the code for such a scenario: ` Here, is the component that's performing asynchronous operations. While loading, the text 'Loading...' is displayed to the user. Great! But what about when things don't go as planned and an error occurs? Currently, Vue's doesn't directly handle errors within its boundary. However, there's a neat workaround. You can use the onErrorCaptured() hook in the parent component of to catch and manage errors. Here's how it works: ` If we run this code, and let’s say that we had an error selecting our Pokemon, this is how it is going to display to the user: The error message is specifically tied to the component where the issue occurred, ensuring that it's the only part of your application that shows an error notification. Meanwhile, the rest of your components will continue to operate and display as intended, maintaining the overall user experience without widespread disruption. This targeted error handling keeps the application's functionality intact while indicating where the problem lies. Conclusion stands out as a formidable feature in Vue.js, transforming the management of asynchronous operations into a more streamlined and user-centric process. It not only elevates the user experience by ensuring smoother interactions during data loading phases but also enhances code maintainability and application performance. I hope you found this blog post enlightening and that it adds value to your Vue.js projects. As always, happy coding and continue to explore the vast possibilities Vue.js offers to make your applications more efficient and engaging!...

Apr 24, 2024

6 mins

VueWeb PerformanceUXJavaScript

3 VueJS Component Libraries Perfect for Beginners

For developers checking out VueJS for the first time, the initial steps are overwhelming, particularly when setting up projects from square one. But don’t worry! The VueJS ecosystem offers a plethora of remarkable component libraries, easing this early obstacle. These three libraries are pre-built toolkits, providing beginners with the means to kickstart their VueJS projects effortlessly. Let’s take a look! Quasar Quasar is among the most popular open-source component libraries for Vue.js, offering a comprehensive set of ready-to-use UI components and tools for building responsive web applications and websites. Designed with performance, flexibility, and ease of use in mind, Quasar provides developers with a wide range of customizable components, such as buttons, forms, dialogs, and layouts, along with built-in support for themes, internationalization, and accessibility. With its extensive documentation, active community support, and seamless integration with Vue CLI and Vuex, Quasar empowers developers to rapidly prototype and develop high-quality Vue.js applications for various platforms, including desktop, mobile, and PWA (Progressive Web Apps). PrimeVue PrimeVue is a popular Vue.js component library offering a wide range of customizable UI components designed for modern web applications. Developed by PrimeTek, it follows Material Design guidelines, ensuring responsiveness and accessibility across devices. With features like theming, internationalization, and advanced functionalities such as lazy loading and drag-and-drop, PrimeVue provides developers with the tools to create elegant and high-performing Vue.js applications efficiently. Supported by clear documentation, demos, and an active community, PrimeVue is an excellent choice for developers seeking to streamline their development process and deliver polished user experiences. Vuetify Vuetify is a powerful Vue.js component library that empowers developers to create elegant and responsive user interfaces with ease. Built according to Google's Material Design guidelines, Vuetify offers a vast collection of customizable UI components, ranging from buttons and cards to navigation bars and data tables. Its comprehensive set of features includes themes, typography, layout grids, and advanced components like dialogues and sliders, enabling developers to quickly build modern web applications that look and feel polished. With extensive documentation, active community support, and ongoing development, Vuetify remains a top choice for Vue.js developers seeking to streamline their workflow and deliver visually stunning user experiences. For newcomers venturing into Vue.js, the initial setup might seem daunting. Thankfully, Vue.js offers a variety of component libraries to simplify this process. Quasar, PrimeVue, and Vuetify are standout options, each providing pre-built tools to kickstart projects smoothly. Whether you prefer Quasar's extensive UI components, PrimeVue's Material Design-inspired features, or Vuetify's responsive interfaces, these libraries cater to diverse preferences and project requirements. With their clear documentation and active communities, these libraries empower developers to start Vue.js projects confidently and efficiently, enabling Vue developers to create polished user experiences....

May 1, 2024

2 mins

VuetifyVueQuasar

Build Advanced Components in Vue 3 using $attrs

In the third major release of Vue js, we have seen many new features and improvements land on our remote working computers. In this article, we are going to cover the $attrs attribute. We will explain what it is used for, how its implementation differs from Vue 2's (former $attrs, class, @listener), and build a code example to help understand its power. Understanding this feature can really support your skills in developing easy to use and scalable components advanced components. What is $attrs? The definition of $attrs, varies between the two major versions of the framework, but in this article, we are going to mainly cover Vue 3, where @attrs can be seen as: > A component property that holds all of the attribute, property, and custom events that are not currently defined within the component. $attrs can also be seen as a safety net, that captures anything that you may not have declared within a component. Let's consider a component that has just a single property and event handler, like the following example: `` If we would instantiate our component like so: `` Our example component would have access to a $attrs property with the following information: `` If the above is not yet making sense, it is absolutely fine. In the next few sections, we will cover, in more granular details, how to actually make use of this feature. $attrs V3 vs $attrs V2 Even if I do not want this article to be a comparison between V2 and V3, it is essential that we touch base on the differences that the $attrs feature offers betweent the two major versions. If you have used VueJs in the past (version 2), there is a significant chance that you have already used $attrs before. The main reason is that almost all the attributes included in the $attrs property were already present in the previous version of the framework. Just split it into different properties. If we take into consideration the example proposed above, the $attrs object is going to appear as follows: Main differences to notice in V2 are: - custom events go into a @listerner bucket - the class is not available (using class in this way requires you to set a property). Most of the content provided in the following chapter can still be applied in V2, as long as we adhere to the above differences and define the extra properties ($listners and a class property). Real Life example As with most of my content, I like to always cover a real life example. Building something from the bottom up, can really help in understanding the reason beind a feature, and help you introduce its usage within your codebase. In the following sections, we are going to build a nice slider (or more precisely a few of them). The complete code can be found on Stackblitz following the following link (stackblitz-vue-example). Let's start from scratch The first step requires us to create a simple component. This is going to be plain Vue and will have nothing to do with the $attrs feature (yet). `` The above code will create a slider that includes single HTML element at the root, and a simple two way binding for a property called value. To use the above component we would do something like this: `` The result should be something like this: Let's add some attributes The above "hello world" example, would never stand the real web development industry. As we know, our components are always full of requirements and specifications, and are never this simple. So to make it a bit more realistic, let's add a couple of attributes (min, max, class, id, data-cy, @keydown and aria-label). `` If we would run the app with the above changes, we would see that all changes take effect. In fact, analysing the app will show the following UI and HTML: As we can notice, all the information has already been applied to our HTML. WAIT A SECOND... Why did I make such a big introduction to $attrs, when all the "non property/event" attributes are already automatically applied to the inner HTML element? Do not worry, I have not wasted your time.. In the next section, we will shake things a bit, because as we know, requirements always change.. :) Change request: Add a title and value In this section we are going to apply some further changes to our component. More precisely, our product owner has assigned us the following ticket: > As a user of the slider, I would like to be able to see a title, and its value in numerical form being shown on screen. The modified component will look like this: `` At first glance, everthing seemed to work, but if we look closely, we can see that something is not right. First, the slider is not blue. Second, the value is going way over 50, and lastly if we look at the html, we'll notice that all of our extra attributes (min, max, data-cy) are assigned to the root element, and not our input element anymore! The best way to solve the above problem would be to find a way to "apply" all the properties, classes, arguments, and events directly to the input field, without them needing to manually declare them- something like a "bucket" of data.. !$ATTRS! Let's jump in the next section and see how we can use $atts to accomplish our goals. $attrs to the rescue At the start of this article, we introduced $attrs as a bucket of information. It is a place that holds all the "undeclared" properties and events, and this is precisely what we need to solve our issue. To use this feature, we can just apply the $attrs property to one or more HTML element, using the v-bind operator: `` As we can see, the above change will make things much better. The use of attrs in our component will act as bridge that copies all out attributes (class, attribute, property and custom events) to one or more elements: The slider thumb is back to being blue. The max value is set to 100, and our extra attributes are set correctly... almost. There is only one problem- our extra attributes have not only been assigned to the input element, but also to the root element! In this case, there is no visual change to show us this issue (and usually there isn't one in real life either. That is why I have not created any). But these extra variables can really create some side effects. Let's fix this. inheritAttrs: false By default, any extra argument being passed to a component is automatically applied to the root element (and to all elements that have the $attrs binding). To switch this feature off, and get control of what elements receive this extra attribute, we can use a flag called inheritAttrs, and set it to false. Our script tag will look like this: `` After this change, our HTML is nice and clean. All the extra properties are applied to the Input element only. Conclusion Before we wrap up, there are a couple of extra points that I want to share, so that you can make furhter use of this feature and understand it more deeply. 1) I prefer not to use the v-model so that I can actually also omit the update:modelValue event (you can see at the file name Slider.vue in the stackblitz code) 2) You can access, and play with the individual properties of the $attrs. So for example, you could apply the $attrs.class to one element, and the $attrs['aria-label]' to another. 3) It is always best to declare property and events, and just use this when you have an element that emits a native event and/or accepts many attributes (like video tag, or all Input fields). Time to say goodbye I have personally taken some time to fully understand this feature, but I really hope that this article may help you in understanding this feature, and helps you define complex but very readable components....

Apr 22, 2021

7 mins

Vue

Reducing Fatigue for On-Call SWEs with AI, Mentorship, & More with Dr. Sally Wabha

In this episode of the Modern Web Podcast, recorded live at All Things Open in Raleigh, NC, hosts Rob Ocel and Danny Thompson sit down with Dr. Sally Wahba, Principal Software Engineer at Splunk. Dr. Wahba shares her experience tackling on-call burnout, offering insights into reducing fatigue through better observability, automation, and thoughtful team practices. The conversation also touches on mentorship and growth in the tech industry, including practical advice for junior engineers navigating the transition from academics to professional roles and tips for companies to better support new talent. Chapters 00:00:13 - Introduction to Marketing This Dot 00:01:00 - Asking for Help Effectively 00:02:21 - Reducing On-Call Fatigue 00:04:42 - Observability Best Practices 00:07:07 - Balancing Alerts and On-Call Efficiency 00:09:30 - The Role of On-Call in Modern Engineering 00:11:29 - Insights from the Grace Hopper Celebration 00:13:56 - Mentorship and Team Dynamics 00:16:14 - Rapid Changes in Technology and Adaptation 00:18:39 - Automation, Observability, and Debugging Challenges 00:21:04 - Addressing the Talent Gap and Junior Engineer Growth 00:24:00 - Closing Thoughts and Where to Learn More Follow Dr. Sally Wahba on Social Media Twitter: https://x.com/sallyky Linkedin: https://linkedin.com/in/sallywahba/ Sponsored by This Dot: thisdot.co...

Nov 27, 2024

1 min

Software EngineeringEngineering Leadership

Let's innovate together!

We're ready to be your trusted technical partners in your digital innovation journey.

Whether it's modernization or custom software solutions, our team of experts can guide you through best practices and how to build scalable, performant software that lasts.

Getting started with Vitepress

Getting started with Vitepress to create your blog site

What is Vitepress

Prerequisites

Create your project

What is available out of the box

Overriding the homepage

Site configuration

Modify the sidebar navigation

Enable Search

Add Favicon to your site

Writing your post

Writing your first page

Blog Frontmatter

Blog Markdown

Customize your blog with Vue

Conclusion

Simone Cuomo

You might also like

Understanding Vue.js's <Suspense> and Async Components

3 VueJS Component Libraries Perfect for Beginners

Build Advanced Components in Vue 3 using $attrs

Reducing Fatigue for On-Call SWEs with AI, Mentorship, & More with Dr. Sally Wabha

Let's innovate together!

You might also like

Understanding Vue.js's <Suspense> and Async Components

3 VueJS Component Libraries Perfect for Beginners

Build Advanced Components in Vue 3 using $attrs

Reducing Fatigue for On-Call SWEs with AI, Mentorship, & More with Dr. Sally Wabha