css-in-js VS JSS

As you might have realized by now, the front end ecosystem is saturated with tools, and unsurprisingly, tools have been invented to partially solve some of the problems with writing CSS at scale. "At scale" means that many developers are working on the same large project and touching the same stylesheets. There is no community-agreed approach on writing CSS in JS at the moment, and we are hoping that one day a winner would emerge, just like Redux did, among all the Flux implementations. For now, we are banking on CSS Modules. CSS modules is an improvement over existing CSS that aims to fix the problem of global namespace in CSS; it enables you to write styles that are local by default and encapsulated to your component. This feature is achieved via tooling. With CSS modules, large teams can write modular and reusable CSS without fear of conflict or overriding other parts of the app. However, at the end of the day, CSS modules are still being compiled into normal globally-namespaced CSS that browsers recognize, and it is still important to learn and understand how raw CSS works.

There are a myriad of CSS-in-JS tools, many of which are zero-runtime giving you all the benefits of authoring in a single file without the drawbacks of inline styles. That's how I prefer to do my CSS with React anyway... Vanilla Extract and/or Linaria are my current favorites.

One thing I think you're really missing is what the output is of CSS-in-JS. There are tens of CSS-in-JS frameworks that can output anything from: CSS Module like classes (Linaria, Vanilla Extract), Atomic Classes (StyleX, PreStyle), to the more traditional (Styled Components, Emotion) many with zero runtime cost (ie no JS bloat). That's why I say CSS-in-JS is primarily about developer experience... the output can often be whatever you want it to be.

Most websites those days are SPA applications that render on the front-side. There is also this trend of CSS in JavaScript also knowns as JSS that is debatable (makes everything overcomplicated), but in some specific cases, can be justified and very useful.

> why tf aren't we using JS for styling already

People are and have been for quite a while

https://cssinjs.org/

JSS

It is possible. At its most simple, you could just modify the style property on every element. That's not generally considered best practice, but there are a number of "CSS-in-JS" libraries which streamline the process. The typically generate dynamic CSS classes and apply them to your elements. A big one is JSS.

import React, { useState, useEffect } from "react"; import Amplify, { API, graphqlOperation } from "aws-amplify"; import { createBlog } from "./graphql/mutations"; import { listBlogs } from "./graphql/queries"; import awsExports from "./aws-exports"; import { ListBlogsQuery } from "./API"; Amplify.configure(awsExports); const initialState = { name: "", body: "" }; const App = () => { const [formState, setFormState] = useState(initialState); const [blogs, setBlogs] = useState(); useEffect(() => { fetchBlogs() }, []); const handleInputChange = (event: React.ChangeEvent) => { setFormState({ ...formState, [event.target.name]: event.target.value }); }; const fetchBlogs = async () => { try { const blogData = (await API.graphql(graphqlOperation(listBlogs))) as { data: ListBlogsQuery } setBlogs(blogData.data); } catch (err) { console.log("Error fetching blogs" + err); } }; const addBlog = async () => { try { if (!formState.name || !formState.body) return; const blog = { ...formState }; if (blogs) { await API.graphql(graphqlOperation(createBlog, { input: blog })); await fetchBlogs(); setFormState(initialState); } } catch (err) { console.log("error creating blog: ", err); } }; return (

Amplify Todos

Create Blog {blogs && blogs?.listBlogs?.items?.map((blog, index) => { return (

{blog?.name}

{blog?.body}

); })}

); }; const styles = { container: { width: 400, margin: "0 auto", display: "flex", //real weird issue: https://github.com/cssinjs/jss/issues/1344 flexDirection: "column" as "column", justifyContent: "center", padding: 20, }, todo: { marginBottom: 15 }, input: { border: "none", backgroundColor: "#ddd", marginBottom: 10, padding: 8, fontSize: 18, }, todoName: { fontSize: 20, fontWeight: "bold" }, todoDescription: { marginBottom: 0 }, button: { backgroundColor: "black", color: "white", outline: "none", fontSize: 18, padding: "12px 0px", }, }; export default App;

Material UI v5 brought some amazing updates, but switching from JSS to Emotion had an arguably nasty side-effect: it was no longer as straightforward to group your component styles in classes. Fortunately, a fantastic library emerged that allowed developers to not only reduce the extreme pain from migrating all their classes from v4's makeStyles to emotion, but to also to continue to writing classes in practically the same syntax, with wonderful TS type-safety. This library was tss-react, and it was one of my favorite open source discoveries of 2021.

I started writing a long response, but I want to add that a simple CRA + JSS + TS (named exports only) stack solves or abstracts away most of these issues.

JSS