`tsx
// hey typescript
interface ButtonProps {
$isActive?: boolean;
$isLoading?: boolean;
}
const SomeButton = cm.button
text-lg
mt-5
${({ $isActive }) => ($isActive ? "bg-blue-400 text-white" : "bg-blue-400 text-blue-200")}
${({ $isLoading }) => $isLoading && "opacity-90 pointer-events-none"}
;
// transforms to
`

$3

we prefix the props incoming to dc with a $ sign. This is a important
convention to distinguish dynamic props from the ones we pass to the component.

_This pattern should also avoid conflicts with reserved prop names._

Create Variants

Create variants by passing an object to the variants key like in
cva. The key should match the
prop name and the value should be a function that returns a string. You could
also re-use the props in the function.

`tsx
interface AlertProps {
$severity: "info" | "warning" | "error";
$isActive?: boolean;
}
const Alert = cm.div.variants({
// optional
base: (p) =>
${p.isActive ? "custom-active" : "custom-inactive"}
p-4
rounded-md
,
// required
variants: {
$severity: {
warning: "bg-yellow-100 text-yellow-800",
info: (p) =>
bg-blue-100 text-blue-800 ${p.$isActive ? "shadow-lg" : ""},
error: (p) =>
bg-red-100 text-red-800 ${p.$isActive ? "ring ring-red-500" : ""},
},
},
// optional - used if no variant was found
defaultVariant: {
$severity: "info",
},
});

export default () => ;
// outputs:


`

$3

As seen above, we also pass AlertProps to the variants, which can cause loose
types. If you want to separate the base props from the variants, you can pass a
second type to the variants function so that only those props are available in
the variants.

`tsx
interface AlertProps {
$isActive?: boolean;
}
interface AlertVariants {
$severity: "info" | "warning" | "error";
}
const Alert = cm.div.variants({
base: p-4 rounded-md,
variants: {
// in here there are only the keys from AlertVariants available
$severity: {
// you can use the props from AlertProps here again
warning: "bg-yellow-100 text-yellow-800",
info: (p) =>
bg-blue-100 text-blue-800 ${p.$isActive ? "shadow-lg" : ""},
error: (p) =>
bg-red-100 text-red-800 ${p.$isActive ? "ring ring-red-500" : ""},
},
},
// optional - used if no variant was found
defaultVariant: {
$severity: "info",
},
});
`

Extend

Extend a component directly by passing the component and the tag name.

`tsx
import MyOtherComponent from "./MyOtherComponent"; // () =>

import cm from "@classmatejs/react";

const Container = cm.extend(MyOtherComponent)
py-2
px-5
min-h-24
;
// transforms to:


`

Add CSS Styles

You can use CSS styles in the template literal string with the style function.
This function takes an object with CSS properties and returns a string. We can
use the props from before.

`tsx
// Base:
const StyledButton = cm.button<{ $isDisabled: boolean }>
text-blue
${(p) =>
p.style({
boxShadow: "0 0 5px rgba(0, 0, 0, 0.1)",
cursor: p.$isDisabled ? "not-allowed" : "pointer",
})}
;
export default () => ;
// outputs:


`

`tsx
// Extended:
const BaseButton = cm.button<{ $isActive?: boolean }>
${(p) =>
p.style({
backgroundColor: p.$isActive ? "green" : "red",
})}
;
const ExtendedButton = cm.extend(BaseButton)<{ $isLoading?: boolean }>
${(p) =>
p.style({
opacity: p.$isLoading ? 0.5 : 1,
pointerEvents: p.$isLoading ? "none" : "auto",
})}
;
export default () => ;
// outputs:


`

$3

When you need to create a classmate component inside another React component
(for example, when the configuration depends on runtime-only values), wrap the
factory with useClassmate. This memoizes the result and avoids creating a
brand-new component on every render.

`tsx
import cm, { useClassmate } from "@classmatejs/react";

const WorkoutDay = ({ status }: { status: "completed" | "pending" }) => {
const StyledDay = useClassmate(
() =>
cm.div.variants({
base: "rounded border p-4 text-sm",
variants: {
$status: {
completed: "border-green-400 bg-green-50",
pending: "border-yellow-400 bg-yellow-50",
},
},
}),
[status], // recompute when dependencies change
);

return Workout details;
};
`

> The dependency array behaves like React.useMemo. Pass everything the factory
> closes over if you expect the component to update when those values change.

$3

Use .logic() to run arbitrary JavaScript once per render before your class
names or variants are computed. The return value is shallow-merged back into the
props, so you can derive $ props, DOM attributes, or anything else your
component needs without additional hooks.

`tsx
type DayStatus = "completed" | "pending"

interface WorkoutProps {
workouts: unknown[]
allResolved: boolean
hasCompleted: boolean
hasSkipped: boolean
$status?: DayStatus
}

const WorkoutDay = cm.div
.logic((props) => {
const status = deriveDayStatus(props)
return {
$status: status,
["data-status"]: status,
}
})
.variants({
base: "rounded border p-4",
variants: {
$status: {
completed: "bg-green-50 border-green-400",
pending: "bg-white border-slate-200",
},
},
})

// Consumers only pass raw workout data – the logic header derives $status for you.

`

> Return values from .logic() are merged in order, so later logic calls can
> reference earlier results or override them.

Recipes for cm.extend

With cm.extend, you can build upon any base React component, adding new styles
and even supporting additional props. This makes it easy to create reusable
component variations without duplicating logic.

`tsx
import { ArrowBigDown } from "lucide-react";
import cm from "@classmatejs/react";

const StyledLucideArrow = cm.extend(ArrowBigDown)
md:-right-4.5
right-1
slide-in-r-20
;

// ts: we can pass only props which are accessible on a lucid-react Component
export default () => ;
`

⚠️ Having problems by extending third party components, see:
Extending other lib components

Now we can define a base component, extend it with additional styles and
classes, and pass properties. You can pass the types to the extend function to
get autocompletion and type checking.

`tsx
import cm from "@classmatejs/react";

interface StyledSliderItemBaseProps {
$active: boolean;
}
const StyledSliderItemBase = cm.button
absolute
h-full
w-full
left-0
top-0
${(p) => (p.$active ? "animate-in fade-in" : "animate-out fade-out")}
;

interface NewStyledSliderItemProps extends StyledSliderItemBaseProps {
$secondBool: boolean;
}
const NewStyledSliderItemWithNewProps = cm.extend(
StyledSliderItemBase,
)
rounded-lg
text-lg
${(p) => (p.$active ? "bg-blue" : "bg-red")}
${(p) => (p.$secondBool ? "text-underline" : "some-class-here")}
;

export default () => (

);
// outputs:


`

$3

`tsx
interface ButtonProps extends InputHTMLAttributes {
$severity: "info" | "warning" | "error";
$isActive?: boolean;
}

const Alert = cm.input.variants({
base: "p-4",
variants: {
$severity: {
info: (p) =>
bg-blue-100 text-blue-800 ${p.$isActive ? "shadow-lg" : ""},
},
},
});

const ExtendedButton = cm.extend(Alert)<{ $test: boolean }>
${(p) => (p.$test ? "bg-green-100 text-green-800" : "")}
;

export default () => ;
// outputs:
`

$3

By passing the component, we can validate the component to accept tag related
props. This is useful if you wanna rely on the props for a specific element
without the $ prefix.

`tsx
// if you pass rc component it's types are validated
const ExtendedButton = cm.extend(cm.button)
some-class
${(p) => (p.type === "submit" ? "font-normal" : "font-bold")}
;

// infers the type of the input element + add new props
const MyInput = ({ ...props }: HTMLAttributes) => (

);
const StyledDiv = cm.extend(MyInput)<{ $trigger?: boolean }>
bg-white
${(p) => (p.$trigger ? "!border-error" : "")}
${(p) => (p.type === "submit" ? "font-normal" : "font-bold")}
;
`

$3

Unfortunately we cannot infer the type directly of the component if it's any
or loosely typed. But we can use a intermediate step to pass the type to the
extend function.

`tsx
import { ComponentProps } from 'react'
import { MapContainer } from 'react-leaflet'
import { Field, FieldConfig } from 'formik'
import cm, { CmBaseComponent } from 'react-classmate'

// we need to cast the type to ComponentProps
type StyledMapContainerType = ComponentProps
const StyledMapContainer: CmBaseComponent = cm.extend(MapContainer)
absolute
h-full
w-full
text-white
outline-0

export const Component = () =>

// or with Formik

import { Field, FieldConfig } from 'formik'

type FieldComponentProps = ComponentProps<'input'> & FieldConfig
const FieldComponent = ({ ...props }: FieldComponentProps) =>

const StyledField = cm.extend(FieldComponent)<{ $error: boolean }>
theme-form-field
w-full
....
${p => (p.$error ? '!border-error' : '')}

export const Component = () =>
`

CommonJS

If you are using CommonJS, you can import the library like this:

`js
const cm = require("@classmatejs/react").default;

// or

const { default: cm } = require("@classmatejs/react");
`

Tailwind Merge

React-classmate uses tailwind-merge
under the hood to merge class names. The last class name will always win, so you
can use it to override classes.

Upcoming

- bug / troubleshoot: classnames set by ref.current (useRef) will be overwritten
as soon component rerenders
- needs at least a small article in the docs
- cm.raw() and cm.raw.variants() for only using rc syntax for classnames
(output as string)
- Variants for cm.extend
- named lib import for CommonJS (currently only .default`) -- Means we need to
remove the named export in the ts file to not duplicate IDE import
suggestions: --- Change postbuild script to remove named esm export
- Integrate more tests, benchmarks focused on SSR and React
- Advanced IDE integration
- show generated default class on hover
- enforce autocompletion and tooltips from the used libs

Inspiration

- tailwind-styled-component
- cva
- twin.macro