Vuetify 3: Titan

Hi, my name is John Leader. I'm the creator and author of Viewtify. And today I wanted to take a little bit of time to talk about Viewtify 3, the next version that will be releasing February of next year. And, uh, some of the different items and aspects the team has been working on as we've been moving through alpha.

Some of the biggest updates that we have are in the form of the baseline creation of all of the basic compute components for the framework are in. We have lots of new design concepts normalized in their, their terminology so that they're more semantic and easier to work with. We have additional interfaces that allow you to, uh, interact with the components and more intuitive ways that allow you to, uh, have more consistent results. And we've also been working a lot on the actual usability of the various parts of the framework from making it easier to manipulate and work with custom styling, as well as how that gets implemented into your project. And some of the new browser features that we get to take advantage of, uh, as we move away from the internet explorer 11 platform.

Okay? So some of the changes and improvements that we have coming from components stated at the beginning, the basic components for the framework are all complete. These are components that form the foundation for larger implementations. Things like alerts and banners ratings, as well as around 42 other basic components that from buttons to chips, avatars, that we use to create and build some of the more complex composition components. We've added a lot of new interfaces for how you can work with these different components, things that simplify the way that you are able to interact and make different design choices and changes within those components. We've also added some additional utility classes to help you in addition to modifying components based upon their normal prop structures, but also being able to make additional changes through the help of utility classes for text and color and different transforms and whatnot.

No. One of the things that we've recently got in the framework that the team has been working on is the form elements and our validation systems. We have a new validation system that is now expanded and it's been added as an available inline provider, as we call them, that allows you to not only implement any type of component or element as a validatable item to an extent, but we've also added new functionality for how you can perform validation, including asynchronous calls in addition to the already existing version two functionality that's available today.

This validation system is built into the new form components in addition to being available inline, as displayed here on the right, where we can now take something that was previously kind of hard coded into inputs and now is something that is flexible and can be used in multiple places. We've also worked a lot on improving the style diversity of input components with a new concept that is in material design called density. I'll talk a little bit more about that later.

In addition to a lot of these new features and functionalities, we still have ported over all of the existing version two styling. That's in addition to the new available options for density that we've created. One of the cool things that we've recently implemented were an animation positioning system for how our menus and our dialogues are what we typically call detachable components, how those operate. And one of the new things that we have that is applied to our system is the way that menus and dialogues animate whenever their activator is clicked is a transform that is based upon the activator's location. So as you can see in the animation here, whenever we open up the dialogue, as opposed to it being an element that just animates from the center of the screen, we're actually now transforming these detachable elements from their original activator location to really kind of improve the visual feel of the actual functionality, but also to improve the performance and how smooth it is whenever you're working with these components so that there is crisp animation, there's no jitteriness, and this is one of my more favorite parts of the new version with all of the way that menus as well work and how they position on the screen. We have a lot more functionality that allows the user to make some really nice aesthetic designs and decisions within their application and just giving the user more options overall.

We have some normalized concepts that I'd like to call semantic customization options that we have began to kind of normalize or pull together multiple different design aspects within beautify and try to put them under a particular category or similar options between multiple components. So that when you're working across the framework, you'll have different components that you're working with, but they'll still be based upon the same kind of interface that you're working with, with multiple different components. And kind of what I mean by that is we have a new concept called variants and what this is, it's a way for us to take some of our mutually design exclusive properties and functionality within version two and kind of put it behind a naming convention so that we can reuse this throughout and actually expand the functionality that is used or available, excuse me, for multiple different components.

An example being the five available that exist primarily in card-based components are contained text, text outline and plane. And in these different design styles are represented in version two, but they're not represented behind any specific naming convention. So what we've kind of done is to homogenize this functionality. We've made it so that it is reusable throughout any card S component alerts. Sheets, banners, list items that give you some additional control over the, not only the, uh, the visual aspect of the component, but, uh, you know, kind of, I stated before, homogenizing making this similar throughout multiple different implementations so that we can, uh, have a similar and same functionality for multiple components that didn't even have the ability to implement these styles in version two.

One of the other things that we have implemented conceptually is, uh, the density from material design and what density is, is a, uh, declaration of how high or vertically, how much a component takes up space-wise whereas size is it modifies components, padding, modifies font size and, and general takes up potentially a larger space on X axis, whereas density, we're just kind of reducing the height. So what we've done here is we've, we've added the ability to combine multiple different aspects of sizing that's available in the framework version two for right now, we have, you know, regular sizing for extra small, small, default, large, extra large. With the introduction of density for version three, we've taken the, some components that you may have worked with that had a, a dense property. It's now been kind of split into two, which those are now compact and comfortable. And these are essentially iterations of a certain pixels, four pixels to be exact, that reduces in scales so that a button or an input will maintain the same visual look. However, it will take up physically less vertical space. And then for components that support both size and density, these actually work together. So you can do things such as having an extra large compact button. If you so choose. And what this does is it gives a lot more options for the user to be able to build their application so that you don't have to have such blocky design or something that is, it takes up a lot of space on the page.

The ability now where you can globally change in the framework, all components of support density to a more compact style. And these are some of the interesting ways that you can interact with these components, like button and inputs list item.

We've worked a lot on the interfaces. We're working with components to give users the ability to solve their problems in different ways. So right now in version 2, most of the components that have what I'd like to call textual interface properties, things as you can see on the slide for properties defining, title, subtitle, text. This exists on some components, but it was never synced in a way that was similar across the framework. So now you're going to have the ability to customize the components in three ways in most situations.

We'll have the default approach, which are elements. This is pretty much what Beautify 2 is now. In some cases, it's very verbose to get to a specific styling, which is required by the structure. For example, if you want to have the card text styling in a card, you have to have a vCardText component. So what we've done is we've kept that as a baseline, but then we went ahead and said, okay, we're going to add some props. We're going to say, you know, you can specify any one of these particular textual interface properties titled text, subtitle, the ability to set avatars or icons common, commonly used in requested features that usually the user kind of has to manually apply themselves. Instead, giving a baseline that is not super flexible in some ways, but is flexible in others. So if you want to just apply some text to a card with title, you can do that with a prop, or you could do it with a slot or it gives you the same markup that you would right. Normally by default with elements, but also you can make additional changes inside of it. So just kind of giving you some flexibility for how you can approach your problems. And you can actually mix and match these together and come up with a unique design and design implementation of your own.

So we have some usability improvements, quality of life changes, things that improve not only either the developer experience, but how we interact. How we and other users interact with the framework as a whole from that perspective. Version two, we used a, we still use SAS, but we used the import approach towards implementation. We've converted our SAS for Vuetify into what are called modules. This is to coincide with new updates to the Vuetify loader and our new VITE plugin, which is available now. And what the purpose of this was is to create a more easy to use interface for SAS, but to also resolve issues that we were having with pre-pinned data and polluting the global variables within SAS. It's also given us the ability to do some pretty cool things like with the new VITE plugin. You can expose the ability to modify any and all styles. This is how you would with version 2, but anything that's not modified and such actually has a pre-compiled CSS file specifically for either that component or functionality that will be used instead of recompiling, which gives drastically faster compilation times, and not only is it considerably faster to work with a view-to-file implementation where you are customizing the variables and you're customizing SASS that's compiled during dev time. Now, not only is that faster, because for components that aren't being used for variables, we already have that pre-compiled, but also we're hooking into Vite, which has been a lot of the team's focus as of late for development process. We've been able to take advantage of some evergreen features from browsers such as Focus Within and CSS variables, working with a button, for example, now provides different visual cues based upon how your interaction occurs with that element. So if you're clicking on a button, chances are you're aware of the location of that button and we don't need it to provide an outline whenever we click on it.

However, if you are tabbing through your application, it may, it's not as obvious whenever a button slightly dims in its opacity. So now we have some new functionality with the advanced browser support to be able to have a distinct visual display based upon how an element is interacted with in regards to the CSS variables. These existed in version two, they're now first class citizens of version three. They're used heavily throughout the framework and are now a kind of the baseline for allowing our customization options within the framework to expand that out and make it not only easier to modify, but giving you more options to change and during those modifications.