Are Custom Properties a “Menu of What Will Change”? | CSS-Tricks

PPK laid out an interesting situation in “Two options for using custom properties” where he and Stefan Judis had two different approaches for doing the same thing with custom properties. In one approach, hover and focus styles for a link are handled with two different custom properties, one for each state. In the other approach, a single custom property is used.

Two custom properties:
.component1 {
–linkcolor: red;
–hovercolor: blue;
}

.component2 {
–linkcolor: purple;
–hovercolor: cyan;
}

a {
color: var(–linkcolor);
}

a:hover,a:focus {
color: var(–hovercolor)
}

One custom property:
.component1 a {
–componentcolor: red;
}

.component1 :is(a:hover,a:focus) {
–componentcolor: blue;
}

.component2 a {
–componentcolor: purple;
}

.component2 :is(a:hover,a:focus) {
–componentcolor: cyan;
}

a {
color: var(–componentcolor)
}

There is something more natural feeling about using two properties, like it’s very explicit about what a particular custom property is meant to do. But there is a lot of elegance to using one custom property. Not just for the sake of being one-less custom property, but that the custom property is 1-to-1 matched with a single property.
Taking this a bit further, you could set up a single ruleset with one custom property per property, giving it a sort of menu for what things will change. To that PPK says:
Now you essentially found a definition file. Not only do you see the component’s default styles, you also see what might change and what will not.
That is to say, you’d use a custom property for anything you intend to change, and anything you don’t, you wouldn’t. That’s certainly an interesting approach that I wouldn’t blame anyone for trying.
.lil-grid {
/* will change */
–padding: 1rem;
padding: var(–padding);
–grid-template-columns: 1fr 1fr 1fr;
grid-columns: var(–grid-template-columns);

/* won’t change */
border: 1px solid #ccc;
gap: 1rem;
}
My hesitation with this is that it’s, at best, a hint at what will and won’t change. For example, I can still change things even though they aren’t set in a custom property. Later, I could do:
.lil-grid.two-up {
grid-columns: 1fr 1fr;
}
That wipes out the custom property usage. Similarly, I could never change the value of –grid-template-columns, meaning it looks like it changes under different circumstances, but never does.
Likewise, I could do:
.lil-grid.thick {
border-width: 3px;
}
…and even though my original component ruleset implies that the border width doesn’t change, it does with a modifier class.
So, in order to make an approach like that work, you treat it like a convention that you stick to, like a generic coding standard. I’d worry it becomes a pain in the butt, though. For any declaration you decide to change, you gotta go back and refactor it to either be or not be a custom property.
This makes me think about the “implicit styling API” that is HTML and CSS. We’ve already got a styling API in browsers. HTML is turned into the DOM in the browser, and we style the DOM with CSS. Select things, style them.
Maybe we don’t need a menu for what you can and cannot style because that’s what the DOM and CSS already are. That’s not to say a well-crafted set of custom properties can’t be a part of that, but they don’t need to represent hardline rules on what changes and what doesn’t.
Speaking of implicit styling APIs, Jim Nielsen writes in “Shadow DOM and Its Effect on the Unofficial Styling API”:
[…] the shadow DOM breaks the self-documenting style API we’ve had on the web for years.What style API? If you want to style an element on screen, you open the dev tools, look at the DOM, find the element you want, figure out the right selector to target that element, write your selector and styles, and you’re done.That’s pretty remarkable when you stop and think about it.
I suppose that’s my biggest beef with web components. I don’t dislike the Shadow DOM; in fact, it’s probably my favorite aspect of web components. I just dislike how I have to invent a styling API for them (à la custom properties that wiggle inside, or ::part) rather than use the styling API that has served us well forever: DOM + CSS.

Typed at

Share your love

Leave a Reply