README
π₯ goober, a less than 1KB css-in-js solution.
πͺ The Great Shave Off Challenge
Can you shave off bytes from goober? Do it and you're gonna get paid! More info here
Motivation
I've always wondered if you could get a working solution for css-in-js with a smaller footprint. While I was working on a side project I wanted to use styled-components, or more accurately the styled
pattern. Looking at the JavaScript bundle sizes, I quickly realized that I would have to include ~12kB(styled-components) or ~11kB(emotion) just so I can use the styled
paradigm. So, I embarked on a mission to create a smaller alternative for these well established APIs.
Why the peanuts emoji?
It's a pun on the tagline.
css-in-js at the cost of peanuts! π₯goober
Table of contents
Usage
The API is inspired by emotion styled
function. Meaning, you call it with your tagName
, and it returns a vDOM component for that tag. Note, setup
needs to be ran before the styled
function is used.
import { h } from 'preact';
import { styled, setup } from 'goober';
// Should be called here, and just once
setup(h);
const Icon = styled('span')`
display: flex;
flex: 1;
color: red;
`;
const Button = styled('button')`
background: dodgerblue;
color: white;
border: ${Math.random()}px solid white;
&:focus,
&:hover {
padding: 1em;
}
.otherClass {
margin: 0;
}
${Icon} {
color: black;
}
`;
Examples
Comparison and tradeoffs
In this section I would like to compare goober, as objectively as I can, with the latest versions of two most well known css-in-js packages: styled-components and emotion.
I've used the following markers to reflect the state of each feature:
- β Supported
- π‘ Partially supported
- π Not supported
Here we go:
Feature name | Goober | Styled Components | Emotion |
---|---|---|---|
Base bundle size | 1.25 kB | 12.6 kB | 7.4 kB |
Framework agnostic | β | π | π |
Render with target *1 | β | π | π |
css api |
β | β | β |
css prop |
β | β | β |
styled |
β | β | β |
styled.<tag> |
β *2 | β | β |
as |
β | β | β |
.withComponent |
π | β | β |
.attrs |
π | β | π |
shouldForwardProp |
β | β | β |
keyframes |
β | β | β |
Labels | π | π | β |
ClassNames | π | π | β |
Global styles | β | β | β |
SSR | β | β | β |
Theming | β | β | β |
Tagged Templates | β | β | β |
Object styles | β | β | β |
Dynamic styles | β | β | β |
Footnotes
- [1]
goober
can render in any dom target. Meaning you can usegoober
to define scoped styles in any context. Really useful for web-components. - [2] Supported only via
babel-plugin-transform-goober
SSR
You can get the critical CSS for SSR via extractCss
. Take a look at this example: CodeSandbox: SSR with Preact and goober and read the full explanation for extractCSS
and targets
below.
Benchmarks
The results are included inside the build output as well.
Browser
Coming soon!
SSR
The benchmark is testing the following scenario:
import styled from 'package';
// Create the dynamic styled component
const Foo = styled('div')((props) => ({
opacity: props.counter > 0.5 ? 1 : 0,
'@media (min-width: 1px)': {
rule: 'all'
},
'&:hover': {
another: 1,
display: 'space'
}
}));
// Serialize the component
renderToString(<Foo counter={Math.random()} />);
The results are:
goober x 200,437 ops/sec Β±1.93% (87 runs sampled)
styled-components@5.2.1 x 12,650 ops/sec Β±9.09% (48 runs sampled)
emotion@11.0.0 x 104,229 ops/sec Β±2.06% (88 runs sampled)
Fastest is: goober
API
As you can see, goober supports most of the CSS syntax. If you find any issues, please submit a ticket, or open a PR with a fix.
styled(tagName: String | Function, forwardRef?: Function)
@param {String|Function} tagName
The name of the DOM element you'd like the styles to be applied to@param {Function} forwardRef
Forward ref function. UsuallyReact.forwardRef
@returns {Function}
Returns the tag template function.
import { styled } from 'goober';
const Btn = styled('button')`
border-radius: 4px;
`;
Different ways of customizing the styles
Tagged templates functions
import { styled } from 'goober';
const Btn = styled('button')`
border-radius: ${(props) => props.size}px;
`;
<Btn size={20} />;
Function that returns a string
import { styled } from 'goober';
const Btn = styled('button')(
(props) => `
border-radius: ${props.size}px;
`
);
<Btn size={20} />;
JSON/Object
import { styled } from 'goober';
const Btn = styled('button')((props) => ({
borderRadius: props.size + 'px'
}));
<Btn size={20} />;
Arrays
import { styled } from 'goober';
const Btn = styled('button')([
{ color: 'tomato' },
({ isPrimary }) => ({ background: isPrimary ? 'cyan' : 'gray' })
]);
<Btn />; // This will render the `Button` with `background: gray;`
<Btn isPrimary />; // This will render the `Button` with `background: cyan;`
Forward ref function
As goober is JSX library agnostic, you need to pass in the forward ref function for the library you are using. Here's how you do it for React.
const Title = styled('h1', React.forwardRef)`
font-weight: bold;
color: dodgerblue;
`;
setup(pragma: Function, prefixer?: Function, theme?: Function, forwardProps?: Function)
The call to setup()
should occur only once. It should be called in the entry file of your project.
Given the fact that react
uses createElement
for the transformed elements and preact
uses h
, setup
should be called with the proper pragma function. This was added to reduce the bundled size and being able to bundle an esmodule version. At the moment, it's the best tradeoff I can think of.
import React from 'react';
import { setup } from 'goober';
setup(React.createElement);
With prefixer
import React from 'react';
import { setup } from 'goober';
const customPrefixer = (key, value) => `${key}: ${value};\n`;
setup(React.createElement, customPrefixer);
With theme
import React, { createContext, useContext, createElement } from 'react';
import { setup, styled } from 'goober';
const theme = { primary: 'blue' };
const ThemeContext = createContext(theme);
const useTheme = () => useContext(ThemeContext);
setup(createElement, undefined, useTheme);
const ContainerWithTheme = styled('div')`
color: ${(props) => props.theme.primary};
`;
With forwardProps
The forwardProps
function offers a way to achieve the same shouldForwardProps
functionality as emotion and styled-components (with transient props) offer. The difference here is that the function receives the whole props and you are in charge of removing the props that should not end up in the DOM.
This is a super useful functionality when paired with theme object, variants, or any other customisation one might need.
import React from 'react';
import { setup, styled } from 'goober';
setup(React.createElement, undefined, undefined, (props) => {
for (let prop in props) {
// Or any other conditions.
// This could also check if this is a dev build and not remove the props
if (prop === 'size') {
delete props[prop];
}
}
});
The functionality of "transient props" (with a "