John Doe
john@doe.com
Hello !
```
Page
}
```
### Start the Panda build process
Run the CLI tool to scan your JavaScript and TypeScript files for style properties and call expressions.
Hello πΌ!
```
```hbs {5} filename="app/templates/application.hbs"
{{page-title 'TestApp'}}
Welcome to Ember
Hello πΌ!
}
export default IndexPage
export const Head: HeadFC = () => Hello πΌ!
}
```
### Start the development server
Run the following command to start the development server:
Hello πΌ!
```
Hello πΌ!
}
export default Home
```
Welcome to the home page
HomePage
Hello World
Hello πΌ!
}
```
Hello πΌ!
}
export default App
```
Hello πΌ!
}
export default App
```
Hello πΌ!
```
Hello πΌ!
}
export default App
```
Hello πΌ!
```
*': { margin: '2' }
})}
/>
)
}
```
This also works with the supported at-rules (`@media`, `@layer`, `@container`, `@supports`, and `@page`):
```tsx
import { css } from '../styled-system/css'
const App = () => {
return (
)
}
```
## Pseudo Classes
### Hover, Active, Focus, and Disabled
You can style the hover, active, focus, and disabled states of an element using their `_` modifier:
```jsx
```
### First, Last, Odd, Even
You can style the first, last, odd, and even elements of a group using their `_` modifier:
```jsx
{items.map(item => (
```
## Pseudo Elements
### Before and After
You can style the `::before` and `::after` pseudo elements of an element using their `_before` and `_after` modifier:
```jsx
```
This modifer for every pseudo class modifiers like `_groupHover`, `_groupActive`, `_groupFocus`, and `_groupDisabled`,
etc.
## Sibling Selectors
When you need to style an element based on its sibling element's state or attribute, you can add the `peer` class to the
sibling element, and use any of the `_peer*` modifiers on the target element.
```jsx
```
> Note: This only works for when the element marked with `peer` is a previous siblings, that is, it comes before the
> element you want to start.
## Data Attribute
### LTR and RTL
You can style an element based on the direction of the text using the `_ltr` and `_rtl` modifiers:
```jsx
```
For this to work, you need to set the `dir` attribute on the parent element. In most cases,you can set this on the
`html` element.
> **Note:** Consider using logical css properties like `marginInlineStart` and `marginInlineEnd` instead their physical
> counterparts like `marginLeft` and `marginRight`. This will reduce the need to use the `_ltr` and `_rtl` modifiers.
### State
You can style an element based on its `data-{state}` attribute using the corresponding `_{state}` modifier:
```jsx
/` syntax:
> The default container syntax is `@/`.
```ts
import { css } from '/styled-system/css'
function Demo() {
return (
)
}
```
This will generate the following CSS:
```css
.cq-type_inline-size {
container-type: inline-size;
}
@container (min-width: 60em) {
.\@\/sm:fs_md {
container-type: inline-size;
}
}
```
You can also named container queries:
```ts
import { cq } from 'styled-system/patterns'
function Demo() {
return (
)
}
```
## Reference
Here's a list of all the condition shortcuts you can use in Panda:
| Condition name | Selector |
| ---------------------- | ------------------------------------------------------------------ |
| \_hover | `&:is(:hover, [data-hover])` |
| \_focus | `&:is(:focus, [data-focus])` |
| \_focusWithin | `&:focus-within` |
| \_focusVisible | `&:is(:focus-visible, [data-focus-visible])` |
| \_disabled | `&:is(:disabled, [disabled], [data-disabled])` |
| \_active | `&:is(:active, [data-active])` |
| \_visited | `&:visited` |
| \_target | `&:target` |
| \_readOnly | `&:is(:read-only, [data-read-only])` |
| \_readWrite | `&:read-write` |
| \_empty | `&:is(:empty, [data-empty])` |
| \_checked | `&:is(:checked, [data-checked], [aria-checked=true])` |
| \_enabled | `&:enabled` |
| \_expanded | `&:is([aria-expanded=true], [data-expanded])` |
| \_highlighted | `&[data-highlighted]` |
| \_before | `&::before` |
| \_after | `&::after` |
| \_firstLetter | `&::first-letter` |
| \_firstLine | `&::first-line` |
| \_marker | `&::marker` |
| \_selection | `&::selection` |
| \_file | `&::file-selector-button` |
| \_backdrop | `&::backdrop` |
| \_first | `&:first-child` |
| \_last | `&:last-child` |
| \_only | `&:only-child` |
| \_even | `&:even` |
| \_odd | `&:odd` |
| \_firstOfType | `&:first-of-type` |
| \_lastOfType | `&:last-of-type` |
| \_onlyOfType | `&:only-of-type` |
| \_peerFocus | `.peer:is(:focus, [data-focus]) ~ &` |
| \_peerHover | `.peer:is(:hover, [data-hover]) ~ &` |
| \_peerActive | `.peer:is(:active, [data-active]) ~ &` |
| \_peerFocusWithin | `.peer:focus-within ~ &` |
| \_peerFocusVisible | `.peer:is(:focus-visible, [data-focus-visible]) ~ &` |
| \_peerDisabled | `.peer:is(:disabled, [disabled], [data-disabled]) ~ &` |
| \_peerChecked | `.peer:is(:checked, [data-checked], [aria-checked=true]) ~ &` |
| \_peerInvalid | `.peer:is(:invalid, [data-invalid], [aria-invalid=true]) ~ &` |
| \_peerExpanded | `.peer:is([aria-expanded=true], [data-expanded]) ~ &` |
| \_peerPlaceholderShown | `.peer:placeholder-shown ~ &` |
| \_groupFocus | `.group:is(:focus, [data-focus]) &` |
| \_groupHover | `.group:is(:hover, [data-hover]) &` |
| \_groupActive | `.group:is(:active, [data-active]) &` |
| \_groupFocusWithin | `.group:focus-within &` |
| \_groupFocusVisible | `.group:is(:focus-visible, [data-focus-visible]) &` |
| \_groupDisabled | `.group:is(:disabled, [disabled], [data-disabled]) &` |
| \_groupChecked | `.group:is(:checked, [data-checked], [aria-checked=true]) &` |
| \_groupExpanded | `.group:is([aria-expanded=true], [data-expanded]) &` |
| \_groupInvalid | `.group:is(:invalid, [data-invalid]) &` |
| \_indeterminate | `&:is(:indeterminate, [data-indeterminate], [aria-checked=mixed])` |
| \_required | `&:is(:required, [data-required], [aria-required=true])` |
| \_valid | `&:is(:valid, [data-valid])` |
| \_invalid | `&:is(:invalid, [data-invalid])` |
| \_autofill | `&:autofill` |
| \_inRange | `&:in-range` |
| \_outOfRange | `&:out-of-range` |
| \_placeholder | `&:is(:placeholder, [data-placeholder])` |
| \_placeholderShown | `&:is(:placeholder-shown, [data-placeholder-shown])` |
| \_pressed | `&:is([aria-pressed=true], [data-pressed])` |
| \_selected | `&:is([aria-selected=true], [data-selected])` |
| \_default | `&:default` |
| \_optional | `&:optional` |
| \_open | `&[open]` |
| \_fullscreen | `&:fullscreen` |
| \_loading | `&:is([data-loading], [aria-busy=true])` |
| \_currentPage | `&[aria-current=page]` |
| \_currentStep | `&[aria-current=step]` |
| \_motionReduce | `@media (prefers-reduced-motion: reduce)` |
| \_motionSafe | `@media (prefers-reduced-motion: no-preference)` |
| \_print | `@media print` |
| \_landscape | `@media (orientation: landscape)` |
| \_portrait | `@media (orientation: portrait)` |
| \_dark | `&.dark, .dark &` |
| \_light | `&.light, .light &` |
| \_osDark | `@media (prefers-color-scheme: dark)` |
| \_osLight | `@media (prefers-color-scheme: light)` |
| \_highContrast | `@media (forced-colors: active)` |
| \_lessContrast | `@media (prefers-contrast: less)` |
| \_moreContrast | `@media (prefers-contrast: more)` |
| \_ltr | `[dir=ltr] &` |
| \_rtl | `[dir=rtl] &` |
| \_scrollbar | `&::-webkit-scrollbar` |
| \_scrollbarThumb | `&::-webkit-scrollbar-thumb` |
| \_scrollbarTrack | `&::-webkit-scrollbar-track` |
| \_horizontal | `&[data-orientation=horizontal]` |
| \_vertical | `&[data-orientation=vertical]` |
## Custom conditions
Panda lets you create your own conditions, so you're not limited to the ones in the default preset. Learn more about
customizing conditions [here](/docs/customization/conditions).
---
## The extend keyword
What is and how to to use the extend keyword
The `extend` keyword allows you to extend the default Panda configuration. It is useful when you want to add your own
customizations to Panda, without erasing the default `presets` values (`conditions`, `tokens`, `utilities`, etc).
It will (deeply) merge your customizations with the default ones, instead of replacing them.
The `extend` keyword allows you to extend the following parts of Panda:
- [conditions](/docs/customization/conditions)
- [theme](/docs/customization/theme)
- [recipes](/docs/concepts/recipes) (included in theme)
- [patterns](/docs/customization/patterns)
- [utilities](/docs/customization/utilities)
- [globalCss](/docs/concepts/writing-styles#global-styles)
- [staticCss](/docs/guides/static)
> These keys are all allowed in [presets](/docs/customization/presets).
## Example
After running the `panda init` command you should see something similar to this:
```ts
import { defineConfig } from '@pandacss/dev'
export default defineConfig({
// ...
// Useful for theme customization
theme: {
extend: {} // π it's already there! perfect, now you just need to add your customizations in this object
}
// ...
})
```
Let's say you want to add a new color to the default theme. You can do it like this:
```ts
import { defineConfig } from '@pandacss/dev'
export default defineConfig({
theme: {
extend: {
colors: {
primary: { value: '#ff0000' }
}
}
}
})
```
This will add a new color to the default theme, without erasing the other ones.
Now, let's say we want to create new property `br` that applies a border radius to an element.
```ts
import { defineConfig } from '@pandacss/dev'
export default defineConfig({
utilities: {
extend: {
br: {
className: 'rounded', // css({ br: "sm" }) => rounded-sm
values: 'radii', // connect values to the radii tokens
transform(value) {
return { borderRadius: value }
}
}
}
}
})
```
What if this utility was coming from a preset (`@acme/my-preset`) ? You can extend any specific part, as it will be
deeply merged with the existing one:
```ts
import { defineConfig } from '@pandacss/dev'
export default defineConfig({
presets: ['@acme/my-preset']
utilities: {
extend: {
br: {
className: 'br' // css({ br: "sm" }) => br-sm
}
}
}
})
```
## Removing something from a preset
Let's say you want to remove the `br` utility from the `@acme/my-preset` preset. You can do it like this:
```ts
import { defineConfig } from '@pandacss/dev'
import myPreset from '@acme/my-preset'
const { br, ...utilities } = myPreset.utilities
export default defineConfig({
presets: ['@acme/my-preset']
utilities: {
extend: {
...utilities, // π we still want the other utilities from this preset
// your customizations here
}
}
})
```
## Removing something from the base presets
Let's say you want to remove the `stack` pattern from the `@pandacss/preset-base` preset (included by default).
You can pick only the parts that you need with and spread the rest, like this:
```ts
import pandaBasePreset from '@pandacss/preset-base'
// omitting stack here
const { stack, ...pandaBasePresetPatterns } = pandaBasePreset.patterns
export default defineConfig({
presets: ['@pandacss/preset-panda'], // π we still want the tokens, breakpoints and textStyles from this preset
// β οΈ we need to eject to prevent the `@pandacss/preset-base` from being resolved
// https://panda-css.com/docs/customization/presets#which-panda-presets-will-be-included-
eject: true,
patterns: {
extend: {
...pandaBasePresetPatterns
// your customizations here
}
}
})
```
## Minimal setup
If you want to use Panda with the bare minimum, without any of the defaults, you can read more about it
[here](/docs/guides/minimal-setup)
## FAQ
### Why is my preset overriding the base one, even after adding it to the array?
You might have forgotten to include the `extend` keyword in your config. Without `extend`, your preset will completely
replace the base one, instead of merging with it.
---
## Panda Integration Hooks
Leveraging hooks in Panda to create custom functionality.
Panda hooks can be used to add new functionality or modify existing behavior during certian parts of the compiler
lifecycle.
Hooks are mostly callbacks that can be added to the panda config via the `hooks` property, or installed via `plugins`.
Here are some examples of what you can do with hooks:
- modify the resolved config (`config:resolved`), like strip out tokens or keyframes.
- modify presets after they are resolved (`preset:resolved`), like removing specific tokens or theme properties from a
preset.
- tweak the design token or classname engine (`tokens:created`, `utility:created`), like prefixing token names, or
customizing the hashing function
- transform a source file to a `tsx` friendly syntax before it's parsed (`parser:before`) so that Panda can
automatically extract its styles usage
- create your own styles parser (`parser:before`, `parser:after`) using the file's content so that Panda could be used
with any templating language
- alter the generated JS and DTS code (`codegen:prepare`)
- modify the generated CSS (`cssgen:done`), allowing all kinds of customizations like removing the unused CSS variables,
etc.
- restrict `strictTokens` to a specific set of token categories, ex: only affect `colors` and `spacing` tokens and
therefore allow any value for `fontSizes` and `lineHeights`
## Examples
### Prefixing token names
This is especially useful when migrating from other css-in-js libraries, [like Stitches.](/docs/migration/stitches)
```ts
import { defineConfig } from '@pandacss/dev'
export default defineConfig({
// ...
hooks: {
'tokens:created': ({ configure }) => {
configure({
formatTokenName: path => '$' + path.join('-')
})
}
}
})
```
### Customizing the hash function
When using the [`hash: true`](/docs/concepts/writing-styles) config property, you can customize the function used to
hash the classnames.
```ts
export default defineConfig({
// ...
hash: true,
hooks: {
'utility:created': ({ configure }) => {
configure({
toHash: (paths, toHash) => {
const stringConds = paths.join(':')
const splitConds = stringConds.split('_')
const hashConds = splitConds.map(toHash)
return hashConds.join('_')
}
})
}
}
})
```
### Modifying the config
Here's an example of how to leveraging the provided `utils` functions in the `config:resolved` hook to remove the
`stack` pattern from the resolved config.
```ts
import { defineConfig } from '@pandacss/dev'
export default defineConfig({
// ...
hooks: {
'config:resolved': ({ config, utils }) => {
return utils.omit(config, ['patterns.stack'])
}
}
})
```
### Modifying presets
You can use the `preset:resolved` hook to modify presets after they are resolved. This is useful for customizing or
filtering out parts of a preset.
```ts
import { defineConfig } from '@pandacss/dev'
export default defineConfig({
// ...
hooks: {
'preset:resolved': ({ utils, preset, name }) => {
if (name === '@pandacss/preset-panda') {
return utils.omit(preset, ['theme.tokens.colors', 'theme.semanticTokens.colors'])
}
return preset
}
}
})
```
### Configuring JSX extraction
Use the `matchTag` / `matchTagProp` functions to customize the way Panda extracts your JSX.
This can be especially useful when working with libraries that have properties that look like CSS properties but are not
and should be ignored.
Let's see a Radix UI example where the `Select.Content` component has a `position` property that should be ignored:
```js
// Here, the `position` property will be extracted because `position` is a valid CSS property, but we don't want that
```
```ts
export default defineConfig({
// ...
hooks: {
'parser:before': ({ configure }) => {
configure({
// ignore the Select.Content entirely
matchTag: tag => tag !== 'Select.Content',
// ...or specifically ignore the `position` property
matchTagProp: (tag, prop) => tag === 'Select.Content' && prop !== 'position'
})
}
}
})
```
### Remove unused variables from final css
Here's an example of how to transform the generated css in the `cssgen:done` hook.
```ts file="panda.config.ts"
import { defineConfig } from '@pandacss/dev'
import { removeUnusedCssVars } from './remove-unused-css-vars'
import { removeUnusedKeyframes } from './remove-unused-keyframes'
export default defineConfig({
// ...
hooks: {
'cssgen:done': ({ artifact, content }) => {
if (artifact === 'styles.css') {
return removeUnusedCssVars(removeUnusedKeyframes(content))
}
}
}
})
```
Get the snippets for the removal logic from our Github Sandbox in the
[remove-unused-css-vars](https://github.com/chakra-ui/panda/blob/main/sandbox/vite-ts/remove-unused-css-vars.ts) and
[remove-unused-keyframes](https://github.com/chakra-ui/panda/blob/main/sandbox/vite-ts/remove-unused-keyframes.ts)
files.
> Note: Using this means you can't use the JS function [`token.var`](/docs/guides/dynamic-styling#using-tokenvar) (or
> [token(xxx)](/docs/guides/dynamic-styling#using-token) where `xxx` is the path to a
> [semanticToken](/docs/theming/tokens#semantic-tokens)) from `styled-system/tokens` as the CSS variables will be
> removed based on the usage found in the generated CSS
## Sharing hooks
Hooks can be shared as a snippet or as a `plugin`. Plugins are currently simple objects that contain a `name` associated
with a `hooks` object with the same structure as the `hooks` object in the config.
> Plugins differ from `presets` as they can't be extended, but they will be called in sequence in the order they are
> defined in the `plugins` array, with the user's config called last.
```ts
import { defineConfig } from '@pandacss/dev'
export default defineConfig({
// ...
plugins: [
{
name: 'token-format',
hooks: {
'tokens:created': ({ configure }) => {
configure({
formatTokenName: path => '$' + path.join('-')
})
}
}
}
]
})
```
## Reference
```ts
export interface PandaHooks {
/**
* Called when the config is resolved, after all the presets are loaded and merged.
* This is the first hook called, you can use it to tweak the config before the context is created.
*/
'config:resolved': (args: ConfigResolvedHookArgs) => MaybeAsyncReturn
/**
* Called when a preset is resolved, allowing you to modify it before it's merged into the config.
*/
'preset:resolved': (args: PresetResolvedHookArgs) => MaybeAsyncReturn
/**
* Called when the token engine has been created
*/
'tokens:created': (args: TokenCreatedHookArgs) => MaybeAsyncReturn
/**
* Called when the classname engine has been created
*/
'utility:created': (args: UtilityCreatedHookArgs) => MaybeAsyncReturn
/**
* Called when the Panda context has been created and the API is ready to be used.
*/
'context:created': (args: ContextCreatedHookArgs) => void
/**
* Called when the config file or one of its dependencies (imports) has changed.
*/
'config:change': (args: ConfigChangeHookArgs) => MaybeAsyncReturn
/**
* Called after reading the file content but before parsing it.
* You can use this hook to transform the file content to a tsx-friendly syntax so that Panda's parser can parse it.
* You can also use this hook to parse the file's content on your side using a custom parser, in this case you don't have to return anything.
*/
'parser:before': (args: ParserResultBeforeHookArgs) => string | void
/**
* Called after the file styles are extracted and processed into the resulting ParserResult object.
* You can also use this hook to add your own extraction results from your custom parser to the ParserResult object.
*/
'parser:after': (args: ParserResultAfterHookArgs) => void
/**
* Called right before writing the codegen files to disk.
* You can use this hook to tweak the codegen files before they are written to disk.
*/
'codegen:prepare': (args: CodegenPrepareHookArgs) => MaybeAsyncReturn
/**
* Called after the codegen is completed
*/
'codegen:done': (args: CodegenDoneHookArgs) => MaybeAsyncReturn
/**
* Called right before adding the design-system CSS (global, static, preflight, tokens, keyframes) to the final CSS
* Called right before writing/injecting the final CSS (styles.css) that contains the design-system CSS and the parser CSS
* You can use it to tweak the CSS content before it's written to disk or injected through the postcss plugin.
*/
'cssgen:done': (args: CssgenDoneHookArgs) => string | void
}
```
---
## JSX Style Context
JSX Style Context provides an ergonomic way to style compound components with slot recipes.
It uses a context-based approach to distribute recipe styles across multiple child components, making it easier to style
headless UI libraries like Ark UI, and Radix UI.
## Atomic Slot Recipe
- Create a slot recipe using the `sva` function
- Pass the slot recipe to the `createStyleContext` function
- Use the `withProvider` and `withContext` functions to create compound components
```tsx
// components/ui/card.tsx
import { sva } from 'styled-system/css'
import { createStyleContext } from 'styled-system/jsx'
const card = sva({
slots: ['root', 'label'],
base: {
root: {},
label: {}
},
variants: {
size: {
sm: { root: {} },
md: { root: {} }
}
},
defaultVariants: {
size: 'sm'
}
})
const { withProvider, withContext } = createStyleContext(card)
const Root = withProvider('div', 'root')
const Label = withContext('label', 'label')
export const Card = {
Root,
Label
}
```
Then you can use the `Root` and `Label` components to create a card.
```tsx
// app/page.tsx
import { Card } from './components/ui/card'
export default function App() {
return (
Hello
)
}
```
## Config Slot Recipe
The `createStyleContext` function can also be used with slot recipes defined in the `panda.config.ts` file.
- Pass the config recipe to the `createStyleContext` function
- Use the `withProvider` and `withContext` functions to create compound components
```tsx
// components/ui/card.tsx
import { card } from '../styled-system/recipes'
import { createStyleContext } from 'styled-system/jsx'
const { withProvider, withContext } = createStyleContext(card)
const Root = withProvider('div', 'root')
const Label = withContext('label', 'label')
export const Card = {
Root,
Label
}
```
Then you can use the `Root` and `Label` components to create a card.
```tsx
// app/page.tsx
import { Card } from './components/ui/card'
export default function App() {
return (
Hello
)
}
```
## createStyleContext
This function is a factory function that returns three functions: `withRootProvider`, `withProvider`, and `withContext`.
### withRootProvider
Creates the root component that provides the style context. Use this when the root component **does not render an
underlying DOM element**.
```tsx
import { Dialog } from '@ark-ui/react'
//...
const DialogRoot = withRootProvider(Dialog.Root)
```
### withProvider
Creates a component that both provides context and applies the root slot styles. Use this when the root component
**renders an underlying DOM element**.
> **Note:** It requires the root `slot` parameter to be passed.
```tsx
import { Avatar } from '@ark-ui/react'
//...
const AvatarRoot = withProvider(Avatar.Root, 'root')
```
### withContext
Creates a component that consumes the style context and applies slot styles. It does not accept variant props directly,
but gets them from context.
```tsx
import { Avatar } from '@ark-ui/react'
//...
const AvatarImage = withContext(Avatar.Image, 'image')
const AvatarFallback = withContext(Avatar.Fallback, 'fallback')
```
### unstyled prop
Every component created with `createStyleContext` supports the `unstyled` prop to disable styling. It is useful when you
want to opt-out of the recipe styles.
- When applied the root component, will disable all styles
- When applied to a child component, will disable the styles for that specific slot
```tsx
// Removes all styles
// Removes only the styles for the image slot
```
## Guides
### Config Recipes
The rules of config recipes still applies when using `createStyleContext`. Ensure the name of the final component
matches the name of the recipe.
> If you want to use a custom name, you can configure the recipe's `jsx` property in the `panda.config.ts` file.
```tsx
// recipe name is "card"
import { card } from '../styled-system/recipes'
const { withRootProvider, withContext } = createStyleContext(card)
const Root = withRootProvider('div')
const Header = withContext('header', 'header')
const Body = withContext('body', 'body')
// The final component name must be "Card"
export const Card = {
Root,
Header,
Body
}
```
### Default Props
Use `defaultProps` option to provide default props to the component.
```tsx
const { withContext } = createStyleContext(card)
export const CardHeader = withContext('header', 'header', {
defaultProps: {
role: 'banner'
}
})
```
---
## Merging Styles
Learn how to merge multiple styles without conflicts.
## Merging `css` objects
You can merge multiple style objects together using the `css` function.
```js
import { css } from 'styled-system/css'
const style1 = {
bg: 'red',
color: 'white'
}
const style2 = {
bg: 'blue'
}
const className = css(style1, style2) // => 'bg_blue text_white'
```
In some cases though, the style object might not be colocated in the same file as the component. In this case, you can
use the `css.raw` function to preserve the original style object.
> All `.raw(...)` signatures are identity functions that return the same value as the input, but > serve as a hint to
> the compiler that the value is a style object.
```js
// style.js
import { css } from 'styled-system/css'
export const style1 = css.raw({
bg: 'red',
color: 'white'
})
// component.js
import { css } from 'styled-system/css'
import { style1 } from './style.js'
const style2 = css.raw({
bg: 'blue'
})
const className = css(style1, style2) // => 'bg_blue text_white'
```
## Merging `cva` + `css` styles
The same technique can be used to merge an atomic `cva` recipe and a style object.
```js
import { css, cx, cva } from 'styled-system/css'
const overrideStyles = css.raw({
bg: 'red',
color: 'white'
})
const buttonStyles = cva({
base: {
bg: 'blue',
border: '1px solid black'
},
variants: {
size: {
small: { fontSize: '12px' }
}
}
})
const className = css(
// returns the resolved style object
buttonStyles.raw({ size: 'small' }),
// add the override styles
overrideStyles
)
// => 'bg_red border_1px_solid_black color_white font-size_12px'
```
## Merging `sva` + `css` styles
The same technique can be used to merge an atomic `sva` recipe and a style object.
```js
import { css, sva } from 'styled-system/css'
const overrideStyles = css.raw({
bg: 'red',
color: 'white'
})
const buttonStyles = sva({
slots: ['root']
base: {
root: {
bg: 'blue',
border: '1px solid black'
}
},
variants: {
size: {
root: {
small: { fontSize: '12px' }
}
}
}
})
// returns the resolved style object for all slots
const { root } = buttonStyles.raw({ size: 'small' })
const className = css(
root,
// add the override styles
overrideStyles
)
// => 'bg_red border_1px_solid_black color_white font-size_12px'
```
## Merging config recipe and style object
Due to the fact that the generated styles of a config recipe are saved in the `@layer recipe` cascade layer, they can be
overridden with any atomic styles. Use the `cx` function to achieve that.
> The `utilties` layer has more precedence than the `recipe` layer.
```js
import { css, cx } from 'styled-system/css'
import { button } from 'styled-system/recipes'
const className = cx(
// returns the resolved class name: `button button--size-small`
button({ size: 'small' }),
// add the override styles
css({ bg: 'red' }) // => 'bg_red'
)
// => 'button button--size-small bg_red'
```
## Merging within JSX component
Using these techniques, you can apply them to a component by exposing a `css` prop and merge with local styles.
> **Note:** For this to work, Panda requires that you set `jsxFramework` config option to `react`
```jsx
const cardStyles = css.raw({
bg: 'red',
color: 'white'
})
function Card({ title, description, css: cssProp }) {
return (
// merge the `cardStyles` with the `cssProp` passed in
)
}
// usage
function Demo() {
return
)
}
```
### Container
The Container pattern is used to create a container with a max-width and center the content.
By default, the container sets the following properties:
- `maxWidth: 8xl`
- `marginX: auto`
- `position: relative`
- `paddingX: { base: 4, md: 6, lg: 8 }`
```tsx
import { container } from '../styled-system/patterns'
function App() {
return (
)
}
```
```tsx
import { Container } from '../styled-system/jsx'
function App() {
return (
)
}
```
### Stack
The Stack pattern is a layout primitive that can be used to create a vertical or horizontal stack of elements.
The `stack` function accepts the following properties:
- `direction`: An alias for the css `flex-direction` property. Default is `column`.
- `gap`: The gap between the elements in the stack.
- `align`: An alias for the css `align-items` property.
- `justify`: An alias for the css `justify-content` property.
```tsx
import { stack } from '../styled-system/patterns'
function App() {
return (
)
}
```
```tsx
import { Stack } from '../styled-system/jsx'
function App() {
return (
)
}
```
#### HStack
The HStack pattern is a wrapper around the `stack` pattern that sets the `direction` property to `horizontal`, and
centers the elements vertically.
```tsx
import { hstack } from '../styled-system/patterns'
function App() {
return (
)
}
```
```tsx
import { HStack } from '../styled-system/jsx'
function App() {
return (
)
}
```
#### VStack
The VStack pattern is a wrapper around the `stack` pattern that sets the `direction` property to `vertical`, and centers
the elements horizontally.
```tsx
import { vstack } from '../styled-system/patterns'
function App() {
return (
)
}
```
```tsx
import { VStack } from '../styled-system/jsx'
function App() {
return (
)
}
```
### Wrap
The Wrap pattern is used to add space between elements and wraps automatically if there isn't enough space.
The `wrap` function accepts the following properties:
- `gap`: The gap between the elements in the stack.
- `columnGap`: The gap between the elements in the stack horizontally.
- `rowGap`: The gap between the elements in the stack vertically.
- `align`: An alias for the css `align-items` property.
- `justify`: An alias for the css `justify-content` property.
```tsx
import { wrap } from '../styled-system/patterns'
function App() {
return (
)
}
```
```tsx
import { Wrap } from '../styled-system/jsx'
function App() {
return (
)
}
```
### Aspect Ratio
The Aspect Ratio pattern is used to create a container with a fixed aspect ratio. It is used when displaying images,
maps, videos and other media.
> **Note:** In most cases, we recommend using the `aspectRatio` property instead of the pattern.
The `aspectRatio` function accepts the following properties:
- `ratio`: The aspect ratio of the container. Can be a number or a string.
```tsx
import { aspectRatio } from '../styled-system/patterns'
function App() {
return (
)
}
```
```tsx
import { AspectRatio } from '../styled-system/jsx'
function App() {
return (
)
}
```
### Flex
The Flex pattern is used to create a flex container and provides some shortcuts for the `flex` property.
The `flex` function accepts the following properties:
- `direction`: The flex direction of the container. Can be `row`, `column`, `row-reverse` or `column-reverse`.
- `wrap`: Whether to wrap the flex items. The value is a boolean.
- `align`: An alias for the css `align-items` property.
- `justify`: An alias for the css `justify-content` property.
- `basis`: An alias for the css `flex-basis` property.
- `grow`: An alias for the css `flex-grow` property.
- `shrink`: An alias for the css `flex-shrink` property.
```tsx
import { flex } from '../styled-system/patterns'
function App() {
return (
)
}
```
```tsx
import { Flex } from '../styled-system/jsx'
function App() {
return (
)
}
```
### Center
The Center pattern is used to center the content of a container.
The `center` function accepts the following properties:
- `inline`: Whether to use `inline-flex` or `flex` for the container. The value is a boolean.
```tsx
import { center } from '../styled-system/patterns'
function App() {
return (
```tsx
import { Center } from '../styled-system/jsx'
function App() {
return (
)
}
```
### LinkOverlay
The link overlay pattern is used to expand a link's clickable area to its nearest parent with `position: relative`.
> We recommend using this pattern when the relative parent contains at most one clickable link.
```tsx
import { css } from '../styled-system/css'
import { linkOverlay } from '../styled-system/patterns'
function App() {
return (
)
}
```
```tsx
import { Box, LinkOverlay } from '../styled-system/jsx'
function App() {
return (
View more
)
}
```
### Float
The Float pattern is used to anchor an element to the top, bottom, left or right of the container.
> It requires a parent element with `position: relative` styles.
The `float` function accepts the following properties:
- `placement`: The placement of the element. Can be `top-start`, `top`, `top-end`, `bottom-start`, `bottom`,
`bottom-end`, `left-start`, `left`, `left-end`, `right-start`, `right` or `right-end`.
- `offset`: The offset of the element from the edge of the container. Can be a number or a string.
- `offsetX`: Same as `offset`, but only for the horizontal axis.
- `offsetY`: Same as `offset`, but only for the vertical axis.
```tsx
import { css } from '../styled-system/css'
import { float } from '../styled-system/patterns'
function App() {
return (
)
}
```
```tsx
import { css } from '../styled-system/css'
import { Float } from '../styled-system/jsx'
function App() {
return (
3
)
}
```
### Grid
The Grid pattern is used to create a grid layout.
The `grid` function accepts the following properties:
- `columns`: The number of columns in the grid.
- `gap`: The gap between the elements in the stack.
- `columnGap`: The gap between the elements in the stack horizontally.
- `rowGap`: The gap between the elements in the stack vertically.
- `minChildWidth`: The minimum width of the child elements before wrapping (must not be used with `columns`).
```tsx
import { grid } from '../styled-system/patterns'
function App() {
return (
)
}
```
```tsx
import { Grid } from '../styled-system/jsx'
function App() {
return (
)
}
```
#### Grid Item
The Grid Item pattern is used to style the children of a grid container.
The `gridItem` function accepts the following properties:
- `colSpan`: The number of columns the item spans.
- `rowSpan`: The number of rows the item spans.
- `rowStart`: The row the item starts at.
- `rowEnd`: The row the item ends at.
- `colStart`: The column the item starts at.
- `colEnd`: The column the item ends at.
```tsx
import { grid, gridItem } from '../styled-system/patterns'
function App() {
return (
)
}
```
```tsx
import { Grid, GridItem } from '../styled-system/jsx'
function App() {
return (
First
Second
Third
)
}
```
### Divider
The Divider pattern is used to create a horizontal or vertical divider.
The `divider` function accepts the following properties:
- `orientation`: The orientation of the divider. Can be `horizontal` or `vertical`.
- `thickness`: The thickness of the divider. Can be a sizing token, or arbitrary value.
- `color`: The color of the divider. Can be a color token, or arbitrary value.
```tsx
import { divider, stack } from '../styled-system/patterns'
function App() {
return (
)
}
```
```tsx
import { Divider, Stack } from '../styled-system/jsx'
function App() {
return (
)
}
```
### Circle
The Circle pattern is used to create a circle.
The `circle` function accepts the following properties:
- `size`: The size of the circle. Can be a sizing token, or arbitrary value.
```tsx
import { circle } from '../styled-system/patterns'
function App() {
return
}
```
```tsx
import { Circle } from '../styled-system/jsx'
function App() {
return
### Square
The Square pattern is used to create a square with equal width and height.
The `square` function accepts the following properties:
- `size`: The size of the square. Can be a sizing token, or arbitrary value.
```tsx
import { square } from '../styled-system/patterns'
function App() {
return
}
```
```tsx
import { Square } from '../styled-system/jsx'
function App() {
return
### Visually Hidden
The Visually Hidden pattern is used to hide an element visually, but keep it accessible to screen readers.
```tsx
import { visuallyHidden } from '../styled-system/patterns'
export function Checkbox() {
return (
)
}
```
### Bleed
The Bleed pattern is used to create a full width element by negating the padding applied to its parent container.
The `bleed` function accepts the following properties:
- `inline`: The amount of padding to negate on the horizontal axis. Should match the parent's padding.
- `block`: The amount of padding to negate on the vertical axis. Should match the parent's padding.
```tsx
import { css } from '../styled-system/css'
import { bleed } from '../styled-system/patterns'
export function Page() {
return (
)
}
```
```tsx
import { css } from '../styled-system/css'
import { Bleed } from '../styled-system/jsx'
export function Page() {
return (
Welcome
)
}
```
### cq (Container Query)
To make it easier to use container queries, we've added a new `cq` pattern to `@pandacss/preset-base`. It is used to
apply styles based on the width of the container.
The `cq` function accepts the following properties:
- `name`: The name of the container query, Maps to the
[`containerName` CSS property](https://developer.mozilla.org/en-US/docs/Web/CSS/container-name).
- `type`: The type of the container query. Maps to the
[`containerType` CSS property](https://developer.mozilla.org/en-US/docs/Web/CSS/container-type). Defaults to
`inline-size`.
```ts
import { cq } from 'styled-system/patterns'
function Demo() {
return (
)
}
```
You can also named container queries:
```tsx
// 1 - Define container conditions
export default defineConfig({
// ...
theme: {
containerNames: ['sidebar', 'content'],
containerSizes: {
xs: '40em',
sm: '60em',
md: '80em'
}
}
})
```
```tsx
// 2 - Automatically generate container query pattern
import { cq } from 'styled-system/patterns'
function Demo() {
return (
)
}
```
Read more about container queries [here](/docs/concepts/conditional-styles#container-queries).
## Usage with JSX
To use the pattern in JSX, you need to set the `jsxFramework` property in the config. When this is set, Panda will emit
files for JSX elements based on the framework.
Every pattern can be used as a JSX element and imported from the `/jsx` entrypoint. By default, the pattern name is the
function name in PascalCase. You can override both the component name (with the `jsx` config property) and the element
rendered (with the `jsxElement` config property).
Learn more about pattern customization [here](/docs/customization/patterns).
```tsx
import { VStack, Center } from '../styled-system/jsx'
function App() {
return (
-
{items.map(item => (
- {item} ))}
| {item} |
Hello
```
#### Notes
- **Before and After**: Ensure you wrap the content value in double quotes.
- **Mixing with Conditions**: When using condition and pseudo elements, prefer to place the condition **before** the
pseudo element.
```jsx
css({
// This works β
_dark: { _backdrop: { color: 'red' } }
// This doesn't work β
_backdrop: { _dark: { color: 'red' } }
})
```
The reason `_backdrop: { _dark: { color: 'red' } }` doesn't work is because it generated an invalid CSS structure that
looks like:
```css
&::backdrop {
&.dark,
.dark & {
color: red;
}
}
```
### Placeholder
Style the placeholder text of any input or textarea using the `_placeholder` modifier:
```jsx
```
### File Inputs
Style the file input button using the `_file` modifier:
```jsx
```
## Media Queries
### Reduced Motion
Use the `_motionReduce` and `_motionSafe` modifiers to style an element based on the user's motion preference:
```jsx
Hello
```
### Color Scheme
The `prefers-color-scheme` media feature is used to detect if the user has requested the system use a light or dark
color theme.
Use the `_osLight` and `_osDark` modifiers to style an element based on the user's color scheme preference:
```jsx
Hello
```
Let's say your app is dark by default, but you want to allow users to switch to a light theme. You can do it like this:
```jsx
Hello
```
### Color Contrast
The `prefers-contrast` media feature is used to detect if the user has requested the system use a high or low contrast
theme.
Use the `_highContrast` and `_lessContrast` modifiers to style an element based on the user's color contrast preference:
```jsx
Hello
```
### Orientation
The `orientation` media feature is used to detect if the user has a device in portrait or landscape mode.
Use the `_portrait` and `_landscape` modifiers to style an element based on the user's device orientation:
```jsx
Hello
```
## Group Selectors
When you need to style an element based on its parent element's state or attribute, you can add the `group` class to the
parent element, and use any of the `_group*` modifiers on the child element.
```jsx
Hover me
Hover me
I'll change by bg
Hello
Hello
```
This also works for common states like `data-active`, `data-disabled`, `data-focus`, `data-hover`, `data-invalid`,
`data-required`, and `data-valid`.
```jsx
Hello
```
> Most of the `data-{state}` attributes typically mirror the corresponding browser pseudo class. For example,
> `data-hover` is equivalent to `:hover`, `data-focus` is equivalent to `:focus`, and `data-active` is equivalent to
> `:active`.
### Orientation
You can style an element based on its `data-orientation` attribute using the `_horizontal` and `_vertical` modifiers:
```jsx
Hello
```
## ARIA Attribute
You can style an element based on its `aria-{state}=true` attribute using the corresponding `_{state}` modifier:
```jsx
Hello
```
> Most of the `aria-{state}` attributes typically mirror the support ARIA states in the browser pseudo class. For
> example, `aria-checked=true` is styled with `_checked`, `aria-disabled=true` is styled with `_disabled`.
## Container queries
You can define container names and sizes in your theme configuration and use them in your styles.
```ts
export default defineConfig({
// ...
theme: {
extend: {
containerNames: ['sidebar', 'content'],
containerSizes: {
xs: '40em',
sm: '60em',
md: '80em'
}
}
}
})
```
The default container sizes in the `@pandacss/preset-panda` preset are shown below:
```ts
export const containerSizes = {
xs: '320px',
sm: '384px',
md: '448px',
lg: '512px',
xl: '576px',
'2xl': '672px',
'3xl': '768px',
'4xl': '896px',
'5xl': '1024px',
'6xl': '1152px',
'7xl': '1280px',
'8xl': '1440px'
}
```
Then use them in your styles by referencing using `@{title}
{description}
{title}
{description}
Cool !
First
Second
Third
First
Second
Third
First
Second
Third
First
Second
Third
First
Second
Third
First
Second
Third
First
Second
Third
First
Second
Third
First
Second
Third
First
Second
Third
First
Second
Third
First
Second
Third
First
Second
Third
3
First
Second
Third
First
Second
Third
First
Second
Third
Welcome
First
Second
Third
This is a title
} // => ``` Here's what the emitted atomic CSS looks like: ```css .font-size_16px { font-size: 16px; } .font-weight_bold { font-weight: bold; } ``` ## The `styled` tag The `styled` tag allows you to create a component with encapsulated styles. It's similar to the `styled-components` or `emotion` library. ```js import { styled } from '../styled-system/jsx' // Create a styled component const Heading = styled.h1` font-size: 16px; font-weight: bold; ` function Demo() { // Use the styled component returnThis is a title
``` Here's what the emitted atomic CSS looks like: ```css .font-size_16px { font-size: 16px; } .font-weight_bold { font-weight: bold; } ``` ## Nested styles You can nest selectors, pseudo-elements and pseudo-selectors. ```js const Button = styled.button` color: black; &:hover { color: blue; } ` ``` Using css nesting syntax, pseudo-elements, pseudo-selectors and combinators are also supported: ```js const Demo = styled.div` color: black; &::after { content: 'πΌ'; } & + & { background: yellow; } &.bordered { border: 1px solid black; } .parent & { color: red; } ` ``` Nested media and container queries are also supported: ```js const Demo = styled.div` color: black; @media (min-width: 200px) { color: blue; } @container (min-width: 200px) { color: red; } ` ``` ## Hashing class names In some cases, it might be useful to shorten the class names by hashing them. Set the `hash: true` option in your `panda.config.ts` file to enable this. This will generate shorter class names but will make it harder to debug. To achieve this, set the `hash` option in your `panda.config.ts` file to `true`: ```ts // panda.config.ts export default defineConfig({ // ... hash: true // optional }) ``` > Run the `codegen` command to regenerate the functions with hashing enabled. When hashing is enabled, the class names will go from this: ```css .font-size_16px { font-size: 16px; } .font-weight_bold { font-weight: bold; } ``` To a unique six character hash regardless of the length of the selector or the number of declarations: ```css .adfg5r { font-size: 16px; } .bsdf35 { font-weight: bold; } ``` ## Using tokens Use the `token()` function or `{}` syntax in your template literals to reference design tokens in your styles. Panda will automatically generate the corresponding CSS variables. ```js import { css } from '../styled-system/css' const className = css` font-size: {fontSizes.md}; font-weight: token(fontWeights.bold, 700); ` ``` ## Caveats The object literal syntax is the recommended way of writing styles. But, if you stick with the template literal syntax, there are some caveats to be aware of: - Patterns and recipes are not generated - Dynamic interpolation or component targeting is not supported - Lack of autocompletion for tokens within the template literal Our [Eslint plugin](https://github.com/chakra-ui/eslint-plugin-panda/blob/main/docs/rules/no-invalid-token-paths.md) can help you overcome this by detecting invalid tokens - JSX Style props are not supported --- ## Virtual Color Panda allows you to create a virtual color or color placeholder in your project. The `colorPalette` property is how you create virtual colors. ```js import { css } from '../styled-system/css' const className = css({ colorPalette: 'blue', bg: 'colorPalette.100', _hover: { bg: 'colorPalette.200' } }) ``` This will translate to the `blue.100` background color and `blue.200` background color on hover. Virtual colors are useful when creating easily customizable components. ## Using with recipes You can also use virtual colors with recipes. ```js import { css, cva, cx } from '../styled-system/css' const button = cva({ base: { padding: 4 // you can also specify a default colorPalette in the `base` recipe key // colorPalette: 'blue', // ^^^^^^^^^^^^^^^^^^^^ }, variants: { variant: { primary: { color: 'colorPalette.500' } } }, defaultVariants: { variant: 'primary' } }) ``` ## Using with different color modes You can also use virtual colors with different conditions, such as color modes. ```js import { css, cva, cx } from '../styled-system/css' const someButton = cva({ base: { padding: 4 }, variants: { variant: { primary: { bg: { base: 'colorPalette.500', _dark: 'colorPalette.200' }, color: { base: 'white', _dark: 'gray.900' } } } }, defaultVariants: { variant: 'primary' } }) export const App = () => { return ( <>Hello World
This is an element with slide-fade-in animation style.
)
}
```
Take advantage of it in your conditions:
```ts
export const popoverSlotRecipe = defineSlotRecipe({
slots: anatomy.keys(),
base: {
content: {
_open: {
animationStyle: 'scale-fade-in'
},
_closed: {
animationStyle: 'scale-fade-out'
}
}
}
})
```
## Best Practices
### Avoid Overuse
To ensure the performance and readability of your design system, avoid overusing animations. Use them sparingly to
enhance user experience without overwhelming the user.
### Consistent Naming Conventions
We recommend using consistent naming conventions for animation styles. Here are common ideas on how to name animation
styles:
- Based on the type of animation (`slide`, `fade`, `bounce`)
- Based on the direction or trigger (`slide-from-top`, `fade-in`, `bounce-on-click`)
- Descriptive or functional names that explain the style's intended use (`modal-open`, `button-hover`, `alert-show`)
By following these guidelines, you can create a clear and maintainable animation system in your design.
---
## Layer Styles
Define reusable container styles properties.
Layer styles provide a way to create consistent and visually appealing elements.
- Color or text color
- Background color
- Border width and border color
- Box shadow
- Opacity
## Defining layer styles
Layer styles are defined in the `layerStyles` property of the theme.
Here's an example of a layer style:
```js filename="layer-styles.ts"
import { defineLayerStyles } from '@pandacss/dev'
const layerStyles = defineLayerStyles({
container: {
description: 'container styles',
value: {
background: 'gray.50',
border: '2px solid',
borderColor: 'gray.500'
}
}
})
```
> **Good to know:** The `value` property maps to style objects that will be applied to the element.
## Update the config
To use the layer styles, we need to update the `config` object in the `panda.config.ts` file.
```js filename="panda.config.ts"
import { defineConfig } from '@pandacss/dev'
import { layerStyles } from './layer-styles'
export default defineConfig({
theme: {
extend: {
layerStyles
}
}
})
```
This should automatically update the generated theme the specified `layerStyles`. If this doesn't happen, you can run
the `panda codegen` command.
## Using layer styles
Now we can use `layerStyle` property in our components.
```jsx
import { css } from '../styled-system/css'
function App() {
return This is inside a container style
}
```
---
## Text Styles
Define reusable typography css properties.
Text styles allows you to define textual css properties. The common properties are:
- The font family, weight, size
- Line height
- Letter spacing
- Text Decoration (strikethrough and underline)
- Text Transform (uppercase, lowercase, and capitalization)
## Defining text styles
Text styles are defined in the `textStyles` property of the theme.
Here's an example of a text style:
```js filename="text-styles.ts"
import { defineTextStyles } from '@pandacss/dev'
export const textStyles = defineTextStyles({
body: {
description: 'The body text style - used in paragraphs',
value: {
fontFamily: 'Inter',
fontWeight: '500',
fontSize: '16px',
lineHeight: '24px',
letterSpacing: '0',
textDecoration: 'None',
textTransform: 'None'
}
}
})
```
> **Good to know:** The `value` property maps to style objects that will be applied to the text.
## Update the config
To use the text styles, we need to update the `config` object in the `panda.config.ts` file.
```js filename="panda.config.ts"
import { defineConfig } from '@pandacss/dev'
import { textStyles } from './text-styles'
export default defineConfig({
theme: {
extend: {
textStyles
}
}
})
```
This should automatically update the generated theme the specified `textStyles`. If this doesn't happen, you can run the
`panda codegen` command.
## Using text styles
Now we can use `textStyle` property in our components.
```jsx
import { css } from '../styled-system/css'
function App() {
return This is a paragraph from Panda with the body text style.
} ``` ## Best Practices ### Avoid layout properties To ensure the consistency of your design system, avoid applying layout properties (like margin, padding, etc.) or color properties (background, colors, etc.) to the text styles. ### Naming conventions We recommend using the same text style names used by designers on your team. Here are common ideas on how to name text styles: - Sized-based naming system (`xs`, `sm`, `md`, `lg`, `xl`) - Semantic naming system that corresponds to respective html tags in production (`caption`, `paragraph`, `h1`, `h2`) - Descriptive or functional naming system that explains the style's intended use (`alert`, `modal-header`, `button-label`) --- ## Tokens Design tokens are the platform-agnostic way to manage design decisions in your application or website. Design tokens provide a platform-agnostic way to manage design decisions through key-value pairs that describe fundamental visual styles. > Design tokens in Panda are largely influenced by the [W3C Token Format](https://tr.designtokens.org/format/). A design token consists of the following properties: - `value`: The value of the token. This can be any valid CSS value. - `description`: An optional description of what the token can be used for. ## Core Tokens Tokens are defined in the `panda.config` file under the `theme` key ```js filename="panda.config.ts" import { defineConfig } from '@pandacss/dev' export default defineConfig({ theme: { // ππ» Define your tokens here extend: { tokens: { colors: { primary: { value: '#0FEE0F' }, secondary: { value: '#EE0F0F' } }, fonts: { body: { value: 'system-ui, sans-serif' } } } } } }) ``` > β οΈ Token values need to be nested in an object with a `value` key. This is to allow for additional properties like > `description` and more in the future. After defining tokens, you can use them in authoring components and styles. ```jsx import { css } from '../styled-system/css' function App() { return (Hello World
) } ``` You can also add an optional description to your tokens. This will be used in the autogenerate token documentation. ```js {8} import { defineConfig } from '@pandacss/dev' export default defineConfig({ theme: { tokens: { colors: { danger: { value: '#EE0F0F', description: 'Color for errors' } } } } }) ``` ## Semantic Tokens Semantic tokens are tokens that are designed to be used in a specific context. In most cases, the value of a semantic token references to an existing token. > To reference a value in a semantic token, use the `{}` syntax. For example, assuming we've defined the following tokens: - `red` and `green` are raw tokens that define the color red and green. - `danger` and `success` are semantic tokens that reference the `red` and `green` tokens. ```js import { defineConfig } from '@pandacss/dev' export default defineConfig({ theme: { tokens: { colors: { red: { value: '#EE0F0F' }, green: { value: '#0FEE0F' } } }, semanticTokens: { colors: { danger: { value: '{colors.red}' }, success: { value: '{colors.green}' } } } } }) ``` > β οΈ Semantic Token values need to be nested in an object with a `value` key. This is to allow for additional properties > like `description` and more in the future. Semantic tokens can also be changed based on the [conditions](/docs/concepts/conditional-styles) like light and dark modes. For example, if you want a color to change automatically based on light or dark mode. ```js import { defineConfig } from '@pandacss/dev' export default defineConfig({ // ... theme: { semanticTokens: { colors: { danger: { value: { base: '{colors.red}', _dark: '{colors.darkred}' } }, success: { value: { base: '{colors.green}', _dark: '{colors.darkgreen}' } } } } } }) ``` > NOTE π¨: The conditions used in semantic tokens must be an at-rule or parent selector > [condition](/docs/concepts/conditional-styles#reference). ## Token Nesting Tokens can be nested to create a hierarchy of tokens. This is useful when you want to group tokens together. > Tip: You can use the `DEFAULT` key to define the default value of a nested token. ```js import { defineConfig } from '@pandacss/dev' export default defineConfig({ // ... theme: { semanticTokens: { colors: { bg: { DEFAULT: { value: '{colors.gray.100}' }, muted: { value: '{colors.gray.100}' } } } } } }) ``` This allows the use of the `bg` token in the following ways: ```jsx import { css } from '../styled-system/css' function App() { return (
Hello World
)
}
```
## Token Types
Panda supports the following token types:
### Colors
Colors have meaning and support the purpose of the content, communicating things like hierarchy of information, and
states. It is mostly defined as a string value or reference to other tokens.
```jsx
const theme = {
tokens: {
colors: {
red: { 100: { value: '#fff1f0' } }
}
}
}
```
### Gradients
Gradient tokens represent a smooth transition between two or more colors. Its value can be defined as a string or a
composite value.
```ts
type Gradient =
| string
| {
type: 'linear' | 'radial'
placement: string | number
stops:
| Array<{
color: string
position: number
}>
| ArrayAccessible only to screen readers
```
## Debug
The debug utility class applies styles to aid in debugging by adding outlines to elements. This can be helpful during
development to visually inspect the layout and structure of your components.
```jsx
Debugging outline applied
```
---
## Interactivity
Panda CSS provides a variety of utility classes to enhance interactivity and user experience on your web applications.
Panda CSS provides a variety of utility classes to enhance interactivity and user experience on your web applications.
These utilities cover aspects such as accent color, caret color, scrolling behavior, scrollbar customization, scroll
margins and paddings, scroll snapping, touch actions, and user selection.
## Accent Color
The `accentColor` utility class sets the accent color of an element. It supports `colors` tokens.
```jsx
Accent color applied
```
## Caret Color
The `caretColor` utility class sets the color of the text cursor (caret) in an input or textarea. It supports `colors`
tokens.
```jsx
```
## Scrollbar
The `scrollbar` utility allows customization of scrollbar appearance. It supports `visible` and `hidden` values which
respectively show or hide the scrollbar.
```jsx
Scrollbar hidden
```
## Scroll Margin
Scroll margin utilities set margins around scroll containers.
```jsx
Scrollbar Container with Inline padding
```
| Prop | CSS Property | Token Category |
| ------------------------------------- | ---------------------------- | -------------- |
| `scrollMarginX` ,`scrollMarginInline` | `scroll-margin-inline` | `spacing` |
| `scrollMarginInlineStart` | `scroll-margin-inline-start` | `spacing` |
| `scrollMarginInlineEnd` | `scroll-margin-inline-end` | `spacing` |
| `scrollMarginY` , `scrollMarginBlock` | `scroll-margin-block` | `spacing` |
| `scrollMarginBlockStart` | `scroll-margin-block-start` | `spacing` |
| `scrollMarginBlockEnd` | `scroll-margin-block-end` | `spacing` |
| `scrollMarginLeft` | `scroll-margin-left` | `spacing` |
| `scrollMarginRight` | `scroll-margin-right` | `spacing` |
| `scrollMarginTop` | `scroll-margin-top` | `spacing` |
| `scrollMarginBottom` | `scroll-margin-bottom` | `spacing` |
## Scroll Padding
Scroll padding utilities set padding inside scroll containers.
```jsx
Scrollbar Container with block padding
```
| Prop | CSS Property | Token Category |
| ---------------------------------------- | ----------------------------- | -------------- |
| `scrollPaddingX` , `scrollPaddingInline` | `scroll-padding-inline` | `spacing` |
| `scrollPaddingInlineStart` | `scroll-padding-inline-start` | `spacing` |
| `scrollPaddingInlineEnd` | `scroll-padding-inline-end` | `spacing` |
| `scrollPaddingY` , `scrollPaddingBlock` | `scroll-padding-block` | `spacing` |
| `scrollPaddingBlockStart` | `scroll-padding-block-start` | `spacing` |
| `scrollPaddingBlockEnd` | `scroll-padding-block-end` | `spacing` |
| `scrollPaddingLeft` | `scroll-padding-left` | `spacing` |
| `scrollPaddingRight` | `scroll-padding-right` | `spacing` |
| `scrollPaddingTop` | `scroll-padding-top` | `spacing` |
| `scrollPaddingBottom` | `scroll-padding-bottom` | `spacing` |
## Scroll Snapping
Scroll snapping utilities provide control over the scroll snap behavior.
### Scroll Snap Margin
| Prop | CSS Property | Token Category |
| ------------------------ | ---------------------- | -------------- |
| `scrollSnapMargin` | `scroll-margin` | `spacing` |
| `scrollSnapMarginTop` | `scroll-margin-top` | `spacing` |
| `scrollSnapMarginBottom` | `scroll-margin-bottom` | `spacing` |
| `scrollSnapMarginLeft` | `scroll-margin-left` | `spacing` |
| `scrollSnapMarginRight` | `scroll-margin-right` | `spacing` |
### Scroll Snap Strictness
It's values can be `mandatory` or `proximity` values, and maps to `var(--scroll-snap-strictness)`.
```jsx
Scroll container with proximity scroll snap
```
### Scroll Snap Type
Supported values
| Value | |
| ------ | ------------------------------------ |
| `none` | `none` |
| `x` | `x var(--scroll-snap-strictness)` |
| `y` | `y var(--scroll-snap-strictness)` |
| `both` | `both var(--scroll-snap-strictness)` |
---
## Layout
Panda provides style properties for styling layout of an element
Panda provides style properties for styling layout of an element.
## Aspect Ratio
Use the `aspectRatio` utilities to set the desired aspect ratio of an element.
Values can reference the `aspectRatios` token category.
```jsx
```
> This uses the native CSS property `aspect-ratio` which is might not supported in all browsers. Consider using the
> [`AspectRatio` pattern](/docs/concepts/patterns#aspect-ratio) instead
## Position
Use the `position` utilities to set the position of an element.
```jsx
// shorthand
```
## Top / Right / Bottom / Left
Use the `top`, `right`, `bottom` and `left` utilities to set the position of an element.
Values can reference the `spacing` token category.
```jsx
```
| Prop | CSS Property | Token Category |
| -------- | ------------ | -------------- |
| `top` | `top` | `spacing` |
| `right` | `right` | `spacing` |
| `bottom` | `bottom` | `spacing` |
| `left` | `left` | `spacing` |
### Logical Properties
Use the `inset{Start|End}` utilities to set the position of an element based on the writing mode.
> For example, `insetStart` will set the `left` property in `ltr` mode and `right` in `rtl` mode.
```jsx
```
| Prop | CSS Property | Token Category |
| ----------------------------------------- | -------------------- | -------------- |
| `start`, `insetStart`, `insetInlineStart` | `inset-inline-start` | `spacing` |
| `end` , `insetEnd`, `insetInlineEnd` | `inset-inline-end` | `spacing` |
| `insetX`, `insetInline` | `inset-inline` | `spacing` |
| `insetY`, `insetBlock` | `inset-inline` | `spacing` |
## Container Query
You can define container names and sizes in your theme configuration and use them in your styles.
[Read more.](/docs/concepts/conditional-styles#container-queries)
| Prop | CSS Property | Token Category |
| --------------- | --------------- | ---------------- |
| `containerName` | `containerName` | `containerNames` |
---
## List
Panda provides utilities for customizing list styles.
Panda provides utilities for customizing list styles.
## List Style Image
Use a custom image as the list marker. It supports the `assets` token category.
```js filename="panda.config.ts"
const theme = {
tokens: {
assets: {
star: {
value: { type: 'svg', value: '' }
}
}
}
}
```
```jsx
```
---
## Outline
Panda provides utilities for customizing outlines.
Panda provides utilities for customizing outlines.
## Compound Property
Set the width, color, and style of the outline.
```jsx
// shorthand
```
| Prop | CSS Property | Token Category |
| ------------------ | ------------ | -------------- |
| `ring` , `outline` | `outline` | `borders` |
## Outline Width
Change the width of the outline.
```jsx
// shorthand
```
| Prop | CSS Property | Token Category |
| ---------------------------- | --------------- | -------------- |
| `ringWidth` , `outlineWidth` | `outline-width` | `borderWidths` |
## Outline Color
Change the color of the outline.
```jsx
// shorthand
```
| Prop | CSS Property | Token Category |
| -------------- | --------------- | -------------- |
| `outlineColor` | `outline-color` | `colors` |
## Outline Offset
Adjust the space between the outline and the element.
```jsx
// shorthand
```
| Prop | CSS Property | Token Category |
| --------------- | ---------------- | -------------- |
| `outlineOffset` | `outline-offset` | `spacing` |
---
## Sizing
Style properties for controlling the size of an element.
Style properties for controlling the size of an element.
## Width
Use the `width` or `w` property to set the width of an element.
```jsx
// shorthand
```
### Fractional width
Use can set fractional widths using the `width` or `w` property.
Values can be within the following ranges:
- Thirds: `1/3` to `2/3`
- Fourths: `1/4` to `3/4`
- Fifths: `1/5` to `4/5`
- Sixths: `1/6` to `5/6`
- Twelfths: `1/12` to `11/12`
```jsx
// shorthand
// shorthand
```
### Max width
Use the `maxWidth` or `maxW` property to set the maximum width of an element.
```jsx
// shorthand
```
### Min width
Use the `minWidth` or `minW` property to set the minimum width of an element.
```jsx
// shorthand
```
| Prop | CSS Property | Token Category |
| ------------------ | ------------ | -------------- |
| `w`, `width` | `width` | `sizes` |
| `maxW`, `maxWidth` | `max-width` | `sizes` |
| `minW`, `minWidth` | `min-width` | `sizes` |
## Height
Use the `height` or `h` property to set the height of an element.
```jsx
// shorthand
```
### Fractional height
Use can set fractional heights using the `height` or `h` property.
Values can be within the following ranges:
- Thirds: `1/3` to `2/3`
- Fourths: `1/4` to `3/4`
- Fifths: `1/5` to `4/5`
- Sixths: `1/6` to `5/6`
```jsx
// shorthand
```
### Relative heights
You can use the modern relative height values `dvh`, `svh`, `lvh`.
```jsx
// shorthand
```
### Max height
Use the `maxHeight` or `maxH` property to set the maximum height of an element.
```jsx
// shorthand
```
### Min height
Use the `minHeight` or `minH` property to set the minimum height of an element.
```jsx
// shorthand
```
| Prop | CSS Property | Token Category |
| ------------------- | ------------ | -------------- |
| `h`, `height` | `height` | `sizes` |
| `maxH`, `maxHeight` | `max-height` | `sizes` |
| `minH`, `minHeight` | `min-height` | `sizes` |
### Size
Use the `boxSize` property to set the width and height of an element.
```jsx
```
| Prop | CSS Property | Token Category |
| --------- | --------------- | -------------- |
| `boxSize` | `width, height` | `sizes` |
---
## Spacing
Style properties for controlling the padding of an element.
## Padding
### All sides
Use the `padding` property to apply padding on all sides of an element
```jsx
// shorthand
```
### Specific sides
Use the `padding{Left|Right|Top|Bottom}` to apply padding on one side of an element
```jsx
// shorthand
// shorthand
```
### Horizontal and Vertical padding
Use the `padding{X|Y}` properties to apply padding on the horizontal and vertical axis of an element
```jsx
// shorthand
// shorthand
```
| Prop | CSS Property | Token Category |
| --------------------- | ---------------- | -------------- |
| `p`,`padding` | `padding` | `spacing` |
| `pl`, `paddingLeft` | `padding-left` | `spacing` |
| `pr`, `paddingRight` | `padding-right` | `spacing` |
| `pt`, `paddingTop` | `padding-top` | `spacing` |
| `pb`, `paddingBottom` | `padding-bottom` | `spacing` |
| `px`, `paddingX` | `padding-inline` | `spacing` |
| `py`, `paddingY` | `padding-block` | `spacing` |
### Logical properties
Use the `padding{Start|End}` properties to apply padding on the logical axis of an element based on the text direction.
```jsx
// shorthand
// shorthand
```
| Prop | CSS Property | Token Category |
| -------------------- | ---------------------- | -------------- |
| `ps`, `paddingStart` | `padding-inline-start` | `spacing` |
| `pe`, `paddingEnd` | `padding-inline-end` | `spacing` |
## Margin
### All sides
Use the `margin` property to apply margin on all sides of an element
```jsx
// shorthand
```
### Specific sides
Use the `margin{Left|Right|Top|Bottom}` to apply margin on one side of an element
```jsx
// shorthand
// shorthand
```
### Horizontal and Vertical margin
Use the `margin{X|Y}` properties to apply margin on the horizontal and vertical axis of an element
```jsx
// shorthand
// shorthand
```
| Prop | CSS Property | Token Category |
| -------------------- | --------------- | -------------- |
| `m`,`margin` | `margin` | `spacing` |
| `ml`, `marginLeft` | `margin-left` | `spacing` |
| `mr`, `marginRight` | `margin-right` | `spacing` |
| `mt`, `marginTop` | `margin-top` | `spacing` |
| `mb`, `marginBottom` | `margin-bottom` | `spacing` |
| `mx`, `marginX` | `margin-left` | `spacing` |
| `my`, `marginY` | `margin-top` | `spacing` |
### Logical properties
Use the `margin{Start|End}` properties to apply margin on the logical axis of an element based on the text direction.
```jsx
// shorthand
// shorthand
```
| Prop | CSS Property | Token Category |
| ------------------- | --------------------- | -------------- |
| `ms`, `marginStart` | `margin-inline-start` | `spacing` |
| `me`, `marginEnd` | `margin-inline-end` | `spacing` |
---
## SVG
Panda provides utilities for styling SVG elements.
Panda provides utilities for styling SVG elements.
## Fill
Change the fill color of an SVG element.
```jsx
```
| Prop | CSS Property | Token Category |
| ------ | ------------ | -------------- |
| `fill` | `fill` | `colors` |
## Stroke
Change the stroke color of an SVG element.
```jsx
```
| Prop | CSS Property | Token Category |
| -------- | ------------ | -------------- |
| `stroke` | `stroke` | colors |
## Stroke Width
Change the stroke width of an SVG element.
```jsx
```
| Prop | CSS Property | Token Category |
| ------------- | -------------- | -------------- |
| `strokeWidth` | `stroke-width` | borderWidths |
---
## Tables
Panda provides utilities for styling tables.
Panda provides utilities for styling tables.
## Border Spacing
Control the border-spacing property of a table.
```jsx
Some long piece of text
Truncated text
```
| Prop | CSS Property | Token Category |
| ----------- | ------------------- | -------------- |
| `lineClamp` | `webkit-line-clamp` | none |
| `truncate` | `text-overflow` | none |
## Text Styles
Utilities for applying a composition of typography properties.
```jsx
Hello World
``` | Prop | Config | | ----------- | ------------ | | `textStyle` | `textStyles` | --- # Customization ## Conditions Learn how to customize conditions in your Panda config Conditions allow you to apply different styles and behaviors based on specific conditions or states. They provide a way to target specific elements or apply styles in response to certain events or conditions. ## Creating a condition To create a condition, you can use the conditions property in the config. Let's say we want to create a `groupHover` pseudo condition that applies styles to an element when a parent container with the `group` role is hovered. ```ts filename="panda.config.ts" import { defineConfig } from '@pandacss/dev' export default defineConfig({ conditions: { extend: { groupHover: '[role=group]:where(:hover, [data-hover]) &' } } }) ``` > β οΈ The `&` character is mandatory, it is a placeholder for the current selector. It will be replaced with the actual > selector when the condition is used. It has to be used either at the beginning or at the end of the condition. Then you can run the following command to generate the conditions JS code:Scrollable content
Dynamic color with runtime value
)
}
// App.tsx
const App = () => {
const [runtimeColor, setRuntimeColor] = useState('pink.300')
return
Dynamic color with runtime value
)
}
const App = () => {
const [runtimeColor, setRuntimeColor] = useState('yellow.300')
return Some content
Some content
Mona Sans
Fira Code
Text
` work as expected. ## Re-using Panda presets Panda offers 2 presets: - `@pandacss/preset-base`: This is a relatively unopinionated set of utilities for mapping CSS properties to values (almost everyone will want these) You can use these presets by installing them via npm and adding them to your `presets` key: ```js export default defineConfig({ // ... presets: ['@pandacss/preset-base'] }) ``` - `@pandacss/preset-panda` as an opinionated set of tokens if you don't want to define your own colors/spacing/fonts etc. ```js export default defineConfig({ // ... presets: ['@pandacss/preset-panda'] }) ``` > Note: You don't need to install `@pandacss/preset-base` or `@pandacss/preset-panda`. Panda will automatically resolve > them for you. --- ## Multi-Theme Tokens Panda supports advance token definition beyond just light/dark mode; theming beyond just dark mode. You can define multi-theme tokens using nested conditions. ## Multi-Theme Tokens Panda supports advance token definition beyond just light/dark mode; theming beyond just dark mode. You can define multi-theme tokens using nested conditions. Let's say your application supports a pink and blue theme, and each theme can have a light and dark mode. Let's see how to model this in Panda. We'll start by defining the following conditions for these theme and color modes: ```js // panda.config.ts const config = { conditions: { light: '[data-color-mode=light] &', dark: '[data-color-mode=dark] &', pinkTheme: '[data-theme=pink] &', blueTheme: '[data-theme=blue] &' } } ``` > Conditions are a way to provide preset css selectors or media queries for use in your Panda project Next, we'll define a `colors.text` semantic token for the pink and blue theme. ```js // panda.config.ts const theme = { // ... semanticTokens: { colors: { text: { value: { _pinkTheme: '{colors.pink.500}', _blueTheme: '{colors.blue.500}' } } } } } ``` Next, we'll modify `colors.text` to support light and dark color modes for each theme. ```js // panda.config.ts const theme = { // ... semanticTokens: { colors: { text: { value: { _pinkTheme: { base: '{colors.pink.500}', _dark: '{colors.pink.300}' }, _blueTheme: { base: '{colors.blue.500}', _dark: '{colors.blue.300}' } } } } } } ``` Now, you can use the `text` token in your styles, and it will automatically change based on the theme and the color scheme. ```jsx // use pink and dark mode themeHello World
// use pink and light mode themeHello World
``` ## Multi-Themes The above example shows you how to define multi-theme tokens using nested conditions but you can also define clearly separated themes using the `themes` property in the config. This allows you to apply a `theme` on multiple tokens at once, using data attributes and CSS variables. > Theme variants can be applied using the `data-panda-theme` attribute with the theme key as the value. ```ts // panda.config.ts import { defineConfig } from '@pandacss/dev' export default defineConfig({ // ... // main theme theme: { extend: { tokens: { colors: { text: { value: 'green' } } }, semanticTokens: { colors: { body: { value: { base: '{colors.green.600}', _osDark: '{colors.green.400}' } } } } } }, // alternative theme variants themes: { primary: { tokens: { colors: { text: { value: 'red' } } }, semanticTokens: { colors: { muted: { value: '{colors.red.200}' }, body: { value: { base: '{colors.red.600}', _osDark: '{colors.red.400}' } } } } }, secondary: { tokens: { colors: { text: { value: 'blue' } } }, semanticTokens: { colors: { muted: { value: '{colors.blue.200}' }, body: { value: { base: '{colors.blue.600}', _osDark: '{colors.blue.400}' } } } } } } }) ``` ### Pregenerating themes By default, no additional theme variant is generated, you need to specify the specific themes you want to generate in `staticCss.themes` to include them in the CSS output. ```ts // panda.config.ts import { defineConfig } from '@pandacss/dev' export default defineConfig({ // ... staticCss: { themes: ['primary', 'secondary'] } }) ``` This will generate the following CSS: ```css @layer tokens { :where(:root, :host) { --colors-text: blue; --colors-body: var(--colors-blue-600); } [data-panda-theme='primary'] { --colors-text: red; --colors-muted: var(--colors-red-200); --colors-body: var(--colors-red-600); } @media (prefers-color-scheme: dark) { :where(:root, :host) { --colors-body: var(--colors-blue-400); } [data-panda-theme='primary'] { --colors-body: var(--colors-red-400); } } } ``` ### Dynamically importing themes An alternative way of applying a theme is by using the new `styled-system/themes` entrypoint where you can import the themes expected CSS and apply them in your app. > βΉοΈ The `styled-system/themes` will always contain every themes (tree-shaken if not used), whereas `staticCss.themes` only > applies to the CSS output. Each theme has a corresponding JSON file with a similar structure: ```json { "name": "primary", "id": "panda-themes-primary", "css": "[data-panda-theme=primary] { ... }" } ``` #### Dynamically import a theme using its name ```ts import { getTheme } from '../styled-system/themes' const theme = await getTheme('red') // ^? { // name: "red"; // id: string; // css: string; // } ``` #### Inject the theme styles into the DOM: ```ts import { injectTheme } from '../styled-system/themes' const theme = await getTheme('red') injectTheme(document.documentElement, theme) // this returns the injected style element ``` #### SSR example with NextJS: ```tsx // app/layout.tsx import { cookies } from 'next/headers' import './globals.css' import { ThemeName, getTheme } from '../../styled-system/themes' export default async function RootLayout({ children }: { children: React.ReactNode }) { const store = cookies() const themeName = store.get('theme')?.value as ThemeName const theme = themeName && (await getTheme(themeName)) return ( {themeName && ( )} {children} ) } ``` ```tsx // app/page.tsx 'use client' import { getTheme, injectTheme } from '../../styled-system/themes' export default function Home() { return ( <> ) } // Set a Cookie function setCookie(cName: string, cValue: any, expDays: number) { let date = new Date() date.setTime(date.getTime() + expDays * 24 * 60 * 60 * 1000) const expires = 'expires=' + date.toUTCString() document.cookie = cName + '=' + cValue + '; ' + expires + '; path=/' } ``` ### Theme contract Finally, you can create a theme contract to ensure that all themes have the same structure: ```ts import { defineThemeContract } from '@pandacss/dev' const defineTheme = defineThemeContract({ tokens: { colors: { red: { value: '' } // theme implementations must have a red color } } }) defineTheme({ tokens: { colors: { // ^^^^ β Property 'red' is missing in type '{}' but required in type '{ red: { value: string; }; }' // // β fixed with // red: { value: 'red' }, } } }) ``` --- ## Static CSS Generator Panda can be used to generate a static set of utility classes for your project. Panda can be used to generate a static set of utility classes for your project. This is useful if you want to use Panda in an HTML project or you want absolute zero runtime. ## Usage To generate a static set of CSS classes, add them to your `panda.config.js` file: ```js export default { staticCss: { // the css properties you want to generate css: [], // the recipes you want to generate recipes: {} } } ``` The `static` property supports two properties: - `css` - an array of CSS properties you want to generate with their `conditions` - `recipes` - the component recipes you want to generate ## Generating CSS Properties The `css` property is an array of CSS properties you want to generate with their `conditions`. You can specify the following options: - `properties`: the CSS properties you want to generate - `conditions`: the CSS conditions or selectors you want to generate in addition to the default values. Values can be `light, dark`, etc. - `responsive`: whether or not to generate responsive classes - `values`: the values you want to generate for the CSS property. When set to `*`, all values defined in the tokens will be included. When set to an array, only the values in the array will be generated. ```js export default { staticCss: { css: [ { properties: { margin: ['*'], padding: ['*', '50px', '80px'] }, responsive: true }, { properties: { color: ['*'], backgroundColor: ['green.200', 'red.400'] }, conditions: ['light', 'dark'] } ] } } ``` ## Generating Recipes The `recipes` property is an object of component recipes you want to generate with their `conditions`. ```js export default { staticCss: { recipes: { button: [ { size: ['sm', 'md'], responsive: true }, { variant: ['*'] } ], // shorthand for all variants tooltip: ['*'] } } } ``` You can also directly specify a recipe's `staticCss` rules from inside a recipe config, e.g.: ```js import { defineRecipe } from '@pandacss/dev' const card = defineRecipe({ className: 'card', base: { color: 'white' }, variants: { size: { small: { fontSize: '14px' }, large: { fontSize: '18px' } } }, staticCss: [{ size: ['*'] }] }) ``` would be the equivalent of defining it inside the main config: ```js import { defineConfig } from '@pandacss/dev' export default defineConfig({ // ... staticCss: { recipes: { card: { size: ['*'] } } } }) ``` Or you could even generate the CSS for every config `recipe` / `slotRecipes` (and each of their variants): ```tsx filename="panda.config.ts" import { defineConfig } from '@pandacss/dev' export default defineConfig({ // ... staticCss: { recipes: '*' } }) ``` This is mostly useful for testing purposes with [`Storybook`](/docs/installation/storybook). ## Removing unused CSS For an even smaller css output size, you can utilize [PurgeCSS](https://purgecss.com/) to treeshake and remove unused CSS. This tool will analyze your template and match selectors against your CSS. --- # Migration ## Migrating from Stitches Migrate your project from Stitches to Panda. This guide helps you migrate from Stitches to Panda and understand the design differences between the libraries. > **Disclaimer:** This isn't about comparing which one is best. Panda and Stitches are two different CSS-in-JS solutions > with design decisions. Here are some similarities between the two libraries. - Panda uses the object literal syntax to define styles. It also supports the shorthand syntax for the `margin` and `padding` properties. - Panda supports the `variants`, `defaultVariants` and `compoundVariants` APIs. - Panda supports design tokens and themes. - Panda supports all the variants of nested selectors (attribute, class, pseudo, descendant, child, sibling selectors and more). It also requires the use of the `&` to chain selectors. Below are some of the differences between the two libraries. ## css function In Stitches, the `css` function is used to author both regular style objects and variant style objects. ```tsx import { css } from '@stitches/react' // definition const styles = css({ border: 'solid 1px red', backgroundColor: 'transparent', variants: { variant: { // ... } } }) // usage ``` In Panda, the `css` function is only used to author atomic styles, and the `cva` function to create variant style objects. **The css function** ```tsx import { css } from '../styled-system/css' // definition const styles = css({ border: 'solid 1px red', backgroundColor: 'transparent' }) // usage ``` **The cva function** ```tsx import { cva } from '../styled-system/css' // definition const styles = cva({ base: { border: 'solid 1px red', backgroundColor: 'transparent' }, variants: { variant: { // ... } } }) // usage ``` ## styled function In Stitches, the `styled` function can be used to create components that are bound to both regular and variant styles objects. ```tsx import { styled } from '@stitches/react' const Button = styled('button', { // base styles backgroundColor: 'gainsboro', borderRadius: '9999px', variants: { // variant styles } }) ``` In Panda, the base styles object needs to added to the `base` key. ```tsx import { styled } from '../styled-system/jsx' const Button = styled('button', { // base styles base: { backgroundColor: 'gainsboro', borderRadius: '9999px' }, variants: { // variant styles } }) ``` In Stitches, the styled function generates a unique className for each variant. ```tsx import { styled } from '@stitches/react' const Button = styled('button', {}) // => ``` In Panda, you can decide if you want unique classNames for the recipe or you want atomic classNames. - **Atomic classes** using the `cva` function or defining the recipe inline in the `styled` function ```tsx import { styled } from '../styled-system/jsx' const Button = styled('button', { base: { backgroundColor: 'gainsboro', borderRadius: '9999px' } }) // => ``` - **Selector classes** by defining the recipe in the `panda.config.ts` file. This approach only generates the classes and css for the variants that are used in the project. ```ts import { defineConfig, defineRecipe } from '@pandacss/dev' const buttonStyle = defineRecipe({ className: 'button', base: { backgroundColor: 'gainsboro', borderRadius: '9999px' }, variants: { // variant styles } }) export default defineConfig({ theme: { extend: { recipes: { buttonStyle } } } }) ``` > You might need to run `panda codegen --clean` to generate the recipe functions. ```tsx import { styled } from '../styled-system/jsx' import { buttonStyle } from '../styled-system/recipes' // create a styled component using the recipe function const Button = styled('button', buttonStyle) // or you can use directly in the JSX // => ``` ## Responsive Styles In Stitches, you configure breakpoints in the `media` key of the `createStitches` method, and use it via the `@Content nested in dark theme.
Box
Box