| import { createColorMixTransform } from "./styled-system/color-mix" |
| import { defineConditions, defineConfig } from "./styled-system/config" |
| import { cssVar } from "./styled-system/css-var" |
|
|
| const isCssVar = (v: string) => /^var\(--.+\)$/.test(v) |
|
|
| const wrap = (str: string, v: any) => (v != null ? `${str}(${v})` : v) |
|
|
| const deg = (v: any) => { |
| if (isCssVar(v) || v == null) return v |
| const unitless = typeof v === "string" && !v.endsWith("deg") |
| return typeof v === "number" || unitless ? `${v}deg` : v |
| } |
|
|
| const createFocusRing = (selector: string) => { |
| return { |
| values: ["outside", "inside", "mixed", "none"], |
| transform(value: any, { token }: any) { |
| const focusRingColor = token("colors.colorPalette.focusRing") |
| const styles: Record<string, any> = { |
| inside: { |
| "--focus-ring-color": focusRingColor, |
| [selector]: { |
| outlineOffset: "0px", |
| outlineWidth: "var(--focus-ring-width, 1px)", |
| outlineColor: "var(--focus-ring-color)", |
| outlineStyle: "var(--focus-ring-style, solid)", |
| borderColor: "var(--focus-ring-color)", |
| }, |
| }, |
| outside: { |
| "--focus-ring-color": focusRingColor, |
| [selector]: { |
| outlineWidth: "var(--focus-ring-width, 2px)", |
| outlineOffset: "var(--focus-ring-offset, 2px)", |
| outlineStyle: "var(--focus-ring-style, solid)", |
| outlineColor: "var(--focus-ring-color)", |
| }, |
| }, |
| mixed: { |
| "--focus-ring-color": focusRingColor, |
| [selector]: { |
| outlineWidth: "var(--focus-ring-width, 3px)", |
| outlineStyle: "var(--focus-ring-style, solid)", |
| outlineColor: |
| "color-mix(in srgb, var(--focus-ring-color), transparent 60%)", |
| borderColor: "var(--focus-ring-color)", |
| }, |
| }, |
| none: { |
| "--focus-ring-color": focusRingColor, |
| [selector]: { |
| outline: "none", |
| }, |
| }, |
| } |
|
|
| return styles[value] ?? {} |
| }, |
| } |
| } |
|
|
| const divideColor = createColorMixTransform("borderColor") |
|
|
| const createTransition = (value: string) => { |
| return { |
| transition: value, |
| transitionTimingFunction: "cubic-bezier(0.4, 0, 0.2, 1)", |
| transitionDuration: "150ms", |
| } |
| } |
|
|
| export const defaultConditions = defineConditions({ |
| hover: [ |
| "@media (hover: hover)", |
| "&:is(:hover, [data-hover]):not(:disabled, [data-disabled])", |
| ], |
| active: |
| "&:is(:active, [data-active]):not(:disabled, [data-disabled], [data-state=open])", |
| focus: "&:is(:focus, [data-focus])", |
| focusWithin: "&:is(:focus-within, [data-focus-within])", |
| focusVisible: "&:is(:focus-visible, [data-focus-visible])", |
| disabled: |
| "&:is(:disabled, [disabled], [data-disabled], [aria-disabled=true])", |
| visited: "&:visited", |
| target: "&:target", |
| readOnly: "&:is([data-readonly], [aria-readonly=true], [readonly])", |
| readWrite: "&:read-write", |
| empty: "&:is(:empty, [data-empty])", |
| checked: |
| "&:is(:checked, [data-checked], [aria-checked=true], [data-state=checked])", |
| enabled: "&:enabled", |
| expanded: |
| "&:is([aria-expanded=true], [data-expanded], [data-state=expanded])", |
| highlighted: "&[data-highlighted]", |
| complete: "&[data-complete]", |
| incomplete: "&[data-incomplete]", |
| dragging: "&[data-dragging]", |
|
|
| before: "&::before", |
| after: "&::after", |
| firstLetter: "&::first-letter", |
| firstLine: "&::first-line", |
| marker: "&::marker", |
| selection: "&::selection", |
| file: "&::file-selector-button", |
| backdrop: "&::backdrop", |
|
|
| first: "&:first-of-type", |
| last: "&:last-of-type", |
| notFirst: "&:not(:first-of-type)", |
| notLast: "&:not(:last-of-type)", |
| only: "&:only-child", |
| even: "&:nth-of-type(even)", |
| odd: "&:nth-of-type(odd)", |
|
|
| peerFocus: ".peer:is(:focus, [data-focus]) ~ &", |
| peerHover: |
| ".peer:is(:hover, [data-hover]):not(:disabled, [data-disabled]) ~ &", |
| peerActive: |
| ".peer:is(:active, [data-active]):not(:disabled, [data-disabled]) ~ &", |
| 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], [data-state=checked]) ~ &", |
| peerInvalid: ".peer:is(:invalid, [data-invalid], [aria-invalid=true]) ~ &", |
| peerExpanded: |
| ".peer:is([aria-expanded=true], [data-expanded], [data-state=expanded]) ~ &", |
| peerPlaceholderShown: ".peer:placeholder-shown ~ &", |
|
|
| groupFocus: ".group:is(:focus, [data-focus]) &", |
| groupHover: |
| ".group:is(:hover, [data-hover]):not(:disabled, [data-disabled]) &", |
| groupActive: |
| ".group:is(:active, [data-active]):not(:disabled, [data-disabled]) &", |
| 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], [data-state=checked]) &", |
| groupExpanded: |
| ".group:is([aria-expanded=true], [data-expanded], [data-state=expanded]) &", |
| groupInvalid: ".group:invalid &", |
|
|
| indeterminate: |
| "&:is(:indeterminate, [data-indeterminate], [aria-checked=mixed], [data-state=indeterminate])", |
| required: "&:is([data-required], [aria-required=true])", |
| valid: "&:is([data-valid], [data-state=valid])", |
| invalid: "&:is([data-invalid], [aria-invalid=true], [data-state=invalid])", |
| autofill: "&:autofill", |
| inRange: "&:is(:in-range, [data-in-range])", |
| outOfRange: "&:is(:out-of-range, [data-outside-range])", |
| placeholder: "&::placeholder, &[data-placeholder]", |
| placeholderShown: "&:is(:placeholder-shown, [data-placeholder-shown])", |
| pressed: "&:is([aria-pressed=true], [data-pressed])", |
| selected: "&:is([aria-selected=true], [data-selected])", |
| grabbed: "&:is([aria-grabbed=true], [data-grabbed])", |
| underValue: "&[data-state=under-value]", |
| overValue: "&[data-state=over-value]", |
| atValue: "&[data-state=at-value]", |
|
|
| default: "&:default", |
| optional: "&:optional", |
| open: "&:is([open], [data-open], [data-state=open])", |
| closed: "&:is([closed], [data-closed], [data-state=closed])", |
| fullscreen: "&is(:fullscreen, [data-fullscreen])", |
| loading: "&:is([data-loading], [aria-busy=true])", |
| hidden: "&:is([hidden], [data-hidden])", |
|
|
| current: "&[data-current]", |
| currentPage: "&[aria-current=page]", |
| currentStep: "&[aria-current=step]", |
| today: "&[data-today]", |
| unavailable: "&[data-unavailable]", |
| rangeStart: "&[data-range-start]", |
| rangeEnd: "&[data-range-end]", |
| now: "&[data-now]", |
| topmost: "&[data-topmost]", |
|
|
| 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 .chakra-theme:not(.light) &", |
| light: ":root &, .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]", |
|
|
| icon: "& :where(svg)", |
| starting: "@starting-style", |
| }) |
|
|
| const currentBgVar = cssVar("bg-currentcolor") |
|
|
| const isCurrentBgVar = (value: string) => |
| value === currentBgVar.ref || value === "currentBg" |
|
|
| const colorValues = (theme: any) => ({ |
| ...theme("colors"), |
| currentBg: currentBgVar, |
| }) |
|
|
| export const defaultBaseConfig = defineConfig({ |
| conditions: defaultConditions, |
| utilities: { |
| |
| background: { |
| values: colorValues, |
| shorthand: ["bg"], |
| transform(value, args) { |
| if (isCurrentBgVar(args.raw)) return { background: currentBgVar.ref } |
| const styleObj = createColorMixTransform("background")(value, args) |
| return { ...styleObj, [currentBgVar.var]: styleObj?.background } |
| }, |
| }, |
| backgroundColor: { |
| values: colorValues, |
| shorthand: ["bgColor"], |
| transform(value, args) { |
| if (isCurrentBgVar(args.raw)) |
| return { backgroundColor: currentBgVar.ref } |
| const styleObj = createColorMixTransform("backgroundColor")(value, args) |
| return { |
| ...styleObj, |
| [currentBgVar.var]: styleObj?.backgroundColor, |
| } |
| }, |
| }, |
| backgroundSize: { shorthand: ["bgSize"] }, |
| backgroundPosition: { shorthand: ["bgPos"] }, |
| backgroundRepeat: { shorthand: ["bgRepeat"] }, |
| backgroundAttachment: { shorthand: ["bgAttachment"] }, |
| backgroundClip: { |
| shorthand: ["bgClip"], |
| values: ["text"], |
| transform(value) { |
| return value === "text" |
| ? { color: "transparent", backgroundClip: "text" } |
| : { backgroundClip: value } |
| }, |
| }, |
| backgroundGradient: { |
| shorthand: ["bgGradient"], |
| values(theme) { |
| return { |
| ...theme("gradients"), |
| "to-t": "linear-gradient(to top, var(--gradient))", |
| "to-tr": "linear-gradient(to top right, var(--gradient))", |
| "to-r": "linear-gradient(to right, var(--gradient))", |
| "to-br": "linear-gradient(to bottom right, var(--gradient))", |
| "to-b": "linear-gradient(to bottom, var(--gradient))", |
| "to-bl": "linear-gradient(to bottom left, var(--gradient))", |
| "to-l": "linear-gradient(to left, var(--gradient))", |
| "to-tl": "linear-gradient(to top left, var(--gradient))", |
| } |
| }, |
| transform(value) { |
| return { |
| "--gradient-stops": "var(--gradient-from), var(--gradient-to)", |
| "--gradient": "var(--gradient-via-stops, var(--gradient-stops))", |
| backgroundImage: value, |
| } |
| }, |
| }, |
| gradientFrom: { |
| values: colorValues, |
| transform: createColorMixTransform("--gradient-from"), |
| }, |
| gradientTo: { |
| values: colorValues, |
| transform: createColorMixTransform("--gradient-to"), |
| }, |
| gradientVia: { |
| values: colorValues, |
| transform(value, args) { |
| const styles = createColorMixTransform("--gradient-via")(value, args) |
| return { |
| ...styles, |
| "--gradient-via-stops": |
| "var(--gradient-from), var(--gradient-via), var(--gradient-to)", |
| } |
| }, |
| }, |
| backgroundImage: { |
| values(theme) { |
| return { ...theme("gradients"), ...theme("assets") } |
| }, |
| shorthand: ["bgImg", "bgImage"], |
| }, |
| |
| border: { values: "borders" }, |
| borderTop: { values: "borders" }, |
| borderLeft: { values: "borders" }, |
| borderBlockStart: { values: "borders" }, |
| borderRight: { values: "borders" }, |
| borderBottom: { values: "borders" }, |
| borderBlockEnd: { values: "borders" }, |
| borderInlineStart: { values: "borders", shorthand: ["borderStart"] }, |
| borderInlineEnd: { values: "borders", shorthand: ["borderEnd"] }, |
| borderInline: { values: "borders", shorthand: ["borderX"] }, |
| borderBlock: { values: "borders", shorthand: ["borderY"] }, |
| |
| borderColor: { |
| values: colorValues, |
| transform: createColorMixTransform("borderColor"), |
| }, |
| borderTopColor: { |
| values: colorValues, |
| transform: createColorMixTransform("borderTopColor"), |
| }, |
| borderBlockStartColor: { |
| values: colorValues, |
| transform: createColorMixTransform("borderBlockStartColor"), |
| }, |
| borderBottomColor: { |
| values: colorValues, |
| transform: createColorMixTransform("borderBottomColor"), |
| }, |
| borderBlockEndColor: { |
| values: colorValues, |
| transform: createColorMixTransform("borderBlockEndColor"), |
| }, |
| borderLeftColor: { |
| values: colorValues, |
| transform: createColorMixTransform("borderLeftColor"), |
| }, |
| borderInlineStartColor: { |
| values: colorValues, |
| shorthand: ["borderStartColor"], |
| transform: createColorMixTransform("borderInlineStartColor"), |
| }, |
| borderRightColor: { |
| values: colorValues, |
| transform: createColorMixTransform("borderRightColor"), |
| }, |
| borderInlineEndColor: { |
| values: colorValues, |
| shorthand: ["borderEndColor"], |
| transform: createColorMixTransform("borderInlineEndColor"), |
| }, |
| |
| borderStyle: { values: "borderStyles" }, |
| borderTopStyle: { values: "borderStyles" }, |
| borderBlockStartStyle: { values: "borderStyles" }, |
| borderBottomStyle: { values: "borderStyles" }, |
| borderBlockEndStyle: { |
| values: "borderStyles", |
| }, |
| borderInlineStartStyle: { |
| values: "borderStyles", |
| shorthand: ["borderStartStyle"], |
| }, |
| borderInlineEndStyle: { |
| values: "borderStyles", |
| shorthand: ["borderEndStyle"], |
| }, |
| borderLeftStyle: { values: "borderStyles" }, |
| borderRightStyle: { values: "borderStyles" }, |
| |
| borderRadius: { values: "radii", shorthand: ["rounded"] }, |
| borderTopLeftRadius: { values: "radii", shorthand: ["roundedTopLeft"] }, |
| borderStartStartRadius: { |
| values: "radii", |
| shorthand: ["roundedStartStart", "borderTopStartRadius"], |
| }, |
| borderEndStartRadius: { |
| values: "radii", |
| shorthand: ["roundedEndStart", "borderBottomStartRadius"], |
| }, |
| borderTopRightRadius: { |
| values: "radii", |
| shorthand: ["roundedTopRight"], |
| }, |
| borderStartEndRadius: { |
| values: "radii", |
| shorthand: ["roundedStartEnd", "borderTopEndRadius"], |
| }, |
| borderEndEndRadius: { |
| values: "radii", |
| shorthand: ["roundedEndEnd", "borderBottomEndRadius"], |
| }, |
| borderBottomLeftRadius: { |
| values: "radii", |
| shorthand: ["roundedBottomLeft"], |
| }, |
| borderBottomRightRadius: { |
| values: "radii", |
| shorthand: ["roundedBottomRight"], |
| }, |
| borderInlineStartRadius: { |
| values: "radii", |
| property: "borderRadius", |
| shorthand: ["roundedStart", "borderStartRadius"], |
| transform: (value) => ({ |
| borderStartStartRadius: value, |
| borderEndStartRadius: value, |
| }), |
| }, |
| borderInlineEndRadius: { |
| values: "radii", |
| property: "borderRadius", |
| shorthand: ["roundedEnd", "borderEndRadius"], |
| transform: (value) => ({ |
| borderStartEndRadius: value, |
| borderEndEndRadius: value, |
| }), |
| }, |
| borderTopRadius: { |
| values: "radii", |
| property: "borderRadius", |
| shorthand: ["roundedTop"], |
| transform: (value) => ({ |
| borderTopLeftRadius: value, |
| borderTopRightRadius: value, |
| }), |
| }, |
| borderBottomRadius: { |
| values: "radii", |
| property: "borderRadius", |
| shorthand: ["roundedBottom"], |
| transform: (value) => ({ |
| borderBottomLeftRadius: value, |
| borderBottomRightRadius: value, |
| }), |
| }, |
| borderLeftRadius: { |
| values: "radii", |
| property: "borderRadius", |
| shorthand: ["roundedLeft"], |
| transform: (value) => ({ |
| borderTopLeftRadius: value, |
| borderBottomLeftRadius: value, |
| }), |
| }, |
| borderRightRadius: { |
| values: "radii", |
| property: "borderRadius", |
| shorthand: ["roundedRight"], |
| transform: (value) => ({ |
| borderTopRightRadius: value, |
| borderBottomRightRadius: value, |
| }), |
| }, |
|
|
| borderWidth: { values: "borderWidths" }, |
| borderBlockStartWidth: { values: "borderWidths" }, |
| borderTopWidth: { values: "borderWidths" }, |
| borderBottomWidth: { values: "borderWidths" }, |
| borderBlockEndWidth: { values: "borderWidths" }, |
| borderRightWidth: { values: "borderWidths" }, |
| borderInlineWidth: { |
| values: "borderWidths", |
| shorthand: ["borderXWidth"], |
| }, |
| borderInlineStartWidth: { |
| values: "borderWidths", |
| shorthand: ["borderStartWidth"], |
| }, |
| borderInlineEndWidth: { |
| values: "borderWidths", |
| shorthand: ["borderEndWidth"], |
| }, |
| borderLeftWidth: { values: "borderWidths" }, |
| borderBlockWidth: { |
| values: "borderWidths", |
| shorthand: ["borderYWidth"], |
| }, |
| |
| color: { |
| values: colorValues, |
| transform: createColorMixTransform("color"), |
| }, |
| fill: { |
| values: colorValues, |
| transform: createColorMixTransform("fill"), |
| }, |
| stroke: { |
| values: colorValues, |
| transform: createColorMixTransform("stroke"), |
| }, |
| accentColor: { |
| values: colorValues, |
| transform: createColorMixTransform("accentColor"), |
| }, |
| |
| divideX: { |
| values: { type: "string" }, |
| transform(value) { |
| return { |
| "& > :not(style, [hidden]) ~ :not(style, [hidden])": { |
| borderInlineStartWidth: value, |
| borderInlineEndWidth: "0px", |
| }, |
| } |
| }, |
| }, |
| divideY: { |
| values: { type: "string" }, |
| transform(value) { |
| return { |
| "& > :not(style, [hidden]) ~ :not(style, [hidden])": { |
| borderTopWidth: value, |
| borderBottomWidth: "0px", |
| }, |
| } |
| }, |
| }, |
| divideColor: { |
| values: colorValues, |
| transform(value, args) { |
| return { |
| "& > :not(style, [hidden]) ~ :not(style, [hidden])": divideColor( |
| value, |
| args, |
| ), |
| } |
| }, |
| }, |
| divideStyle: { |
| property: "borderStyle", |
| transform(value) { |
| return { |
| "& > :not(style, [hidden]) ~ :not(style, [hidden])": { |
| borderStyle: value, |
| }, |
| } |
| }, |
| }, |
| |
| boxShadow: { values: "shadows", shorthand: ["shadow"] }, |
| boxShadowColor: { |
| values: colorValues, |
| transform: createColorMixTransform("--shadow-color"), |
| shorthand: ["shadowColor"], |
| }, |
| mixBlendMode: { shorthand: ["blendMode"] }, |
| backgroundBlendMode: { shorthand: ["bgBlendMode"] }, |
| opacity: { values: "opacity" }, |
| |
| filter: { |
| transform(v) { |
| if (v !== "auto") { |
| return { filter: v } |
| } |
| return { |
| filter: `var(--blur) var(--brightness) var(--contrast) var(--grayscale) var(--hue-rotate) var(--invert) var(--saturate) var(--sepia) var(--drop-shadow)`, |
| } |
| }, |
| }, |
| blur: { |
| values: "blurs", |
| transform: (v) => ({ "--blur": wrap("blur", v) }), |
| }, |
| brightness: { |
| transform: (v) => ({ "--brightness": wrap("brightness", v) }), |
| }, |
| contrast: { |
| transform: (v) => ({ "--contrast": wrap("contrast", v) }), |
| }, |
| grayscale: { |
| transform: (v) => ({ "--grayscale": wrap("grayscale", v) }), |
| }, |
| hueRotate: { |
| transform: (v) => ({ "--hue-rotate": wrap("hue-rotate", deg(v)) }), |
| }, |
| invert: { transform: (v) => ({ "--invert": wrap("invert", v) }) }, |
| saturate: { |
| transform: (v) => ({ "--saturate": wrap("saturate", v) }), |
| }, |
| sepia: { transform: (v) => ({ "--sepia": wrap("sepia", v) }) }, |
| dropShadow: { |
| transform: (v) => ({ "--drop-shadow": wrap("drop-shadow", v) }), |
| }, |
| |
| backdropFilter: { |
| transform(v) { |
| if (v !== "auto") { |
| return { backdropFilter: v } |
| } |
| return { |
| backdropFilter: `var(--backdrop-blur) var(--backdrop-brightness) var(--backdrop-contrast) var(--backdrop-grayscale) var(--backdrop-hue-rotate) var(--backdrop-invert) var(--backdrop-opacity) var(--backdrop-saturate) var(--backdrop-sepia)`, |
| } |
| }, |
| }, |
| backdropBlur: { |
| values: "blurs", |
| transform: (v) => ({ "--backdrop-blur": wrap("blur", v) }), |
| }, |
| backdropBrightness: { |
| transform: (v) => ({ |
| "--backdrop-brightness": wrap("brightness", v), |
| }), |
| }, |
| backdropContrast: { |
| transform: (v) => ({ "--backdrop-contrast": wrap("contrast", v) }), |
| }, |
| backdropGrayscale: { |
| transform: (v) => ({ |
| "--backdrop-grayscale": wrap("grayscale", v), |
| }), |
| }, |
| backdropHueRotate: { |
| transform: (v) => ({ |
| "--backdrop-hue-rotate": wrap("hue-rotate", deg(v)), |
| }), |
| }, |
| backdropInvert: { |
| transform: (v) => ({ "--backdrop-invert": wrap("invert", v) }), |
| }, |
| backdropOpacity: { |
| transform: (v) => ({ "--backdrop-opacity": wrap("opacity", v) }), |
| }, |
| backdropSaturate: { |
| transform: (v) => ({ "--backdrop-saturate": wrap("saturate", v) }), |
| }, |
| backdropSepia: { |
| transform: (v) => ({ "--backdrop-sepia": wrap("sepia", v) }), |
| }, |
| |
| flexBasis: { values: "sizes" }, |
| gap: { values: "spacing" }, |
| rowGap: { values: "spacing", shorthand: ["gapY"] }, |
| columnGap: { values: "spacing", shorthand: ["gapX"] }, |
| flexDirection: { shorthand: ["flexDir"] }, |
| |
| gridGap: { values: "spacing" }, |
| gridColumnGap: { values: "spacing" }, |
| gridRowGap: { values: "spacing" }, |
| |
| outlineColor: { |
| values: colorValues, |
| transform: createColorMixTransform("outlineColor"), |
| }, |
| focusRing: createFocusRing("&:is(:focus, [data-focus])"), |
| focusVisibleRing: createFocusRing( |
| "&:is(:focus-visible, [data-focus-visible])", |
| ), |
| focusRingColor: { |
| values: colorValues, |
| transform: createColorMixTransform("--focus-ring-color"), |
| }, |
| focusRingOffset: { |
| values: "spacing", |
| transform: (v) => ({ "--focus-ring-offset": v }), |
| }, |
| focusRingWidth: { |
| values: "borderWidths", |
| property: "outlineWidth", |
| transform: (v) => ({ "--focus-ring-width": v }), |
| }, |
| focusRingStyle: { |
| values: "borderStyles", |
| property: "outlineStyle", |
| transform: (v) => ({ "--focus-ring-style": v }), |
| }, |
| |
| aspectRatio: { values: "aspectRatios" }, |
| width: { values: "sizes", shorthand: ["w"] }, |
| inlineSize: { values: "sizes" }, |
| height: { values: "sizes", shorthand: ["h"] }, |
| blockSize: { values: "sizes" }, |
| boxSize: { |
| values: "sizes", |
| property: "width", |
| transform: (v) => ({ width: v, height: v }), |
| }, |
| minWidth: { values: "sizes", shorthand: ["minW"] }, |
| minInlineSize: { values: "sizes" }, |
| minHeight: { values: "sizes", shorthand: ["minH"] }, |
| minBlockSize: { values: "sizes" }, |
| maxWidth: { values: "sizes", shorthand: ["maxW"] }, |
| maxInlineSize: { values: "sizes" }, |
| maxHeight: { values: "sizes", shorthand: ["maxH"] }, |
| maxBlockSize: { values: "sizes" }, |
| hideFrom: { |
| values: "breakpoints", |
| |
| transform: (value, { raw, token }) => { |
| const bp = token.raw(`breakpoints.${raw}`) |
| const media = bp |
| ? `@breakpoint ${raw}` |
| : `@media screen and (min-width: ${value})` |
| return { |
| [media]: { display: "none" }, |
| } |
| }, |
| }, |
| hideBelow: { |
| values: "breakpoints", |
| |
| transform(value, { raw, token }) { |
| const bp = token.raw(`breakpoints.${raw}`) |
| const media = bp |
| ? `@breakpoint ${raw}Down` |
| : `@media screen and (max-width: ${value})` |
| return { |
| [media]: { |
| display: "none", |
| }, |
| } |
| }, |
| }, |
| |
| overscrollBehavior: { shorthand: ["overscroll"] }, |
| overscrollBehaviorX: { shorthand: ["overscrollX"] }, |
| overscrollBehaviorY: { shorthand: ["overscrollY"] }, |
| scrollbar: { |
| values: ["visible", "hidden"], |
| transform(v) { |
| switch (v) { |
| case "visible": |
| return { |
| msOverflowStyle: "auto", |
| scrollbarWidth: "auto", |
| "&::-webkit-scrollbar": { display: "block" }, |
| } |
| case "hidden": |
| return { |
| msOverflowStyle: "none", |
| scrollbarWidth: "none", |
| "&::-webkit-scrollbar": { display: "none" }, |
| } |
| default: |
| return {} |
| } |
| }, |
| }, |
| scrollbarColor: { |
| values: colorValues, |
| transform: createColorMixTransform("scrollbarColor"), |
| }, |
| scrollbarGutter: { values: "spacing" }, |
| scrollbarWidth: { values: "sizes" }, |
| |
| scrollMargin: { values: "spacing" }, |
| scrollMarginTop: { values: "spacing" }, |
| scrollMarginBottom: { values: "spacing" }, |
| scrollMarginLeft: { values: "spacing" }, |
| scrollMarginRight: { values: "spacing" }, |
| scrollMarginX: { |
| values: "spacing", |
| transform: (v) => ({ scrollMarginLeft: v, scrollMarginRight: v }), |
| }, |
| scrollMarginY: { |
| values: "spacing", |
| transform: (v) => ({ scrollMarginTop: v, scrollMarginBottom: v }), |
| }, |
| |
| scrollPadding: { values: "spacing" }, |
| scrollPaddingTop: { values: "spacing" }, |
| scrollPaddingBottom: { values: "spacing" }, |
| scrollPaddingLeft: { values: "spacing" }, |
| scrollPaddingRight: { values: "spacing" }, |
| scrollPaddingInline: { values: "spacing", shorthand: ["scrollPaddingX"] }, |
| scrollPaddingBlock: { values: "spacing", shorthand: ["scrollPaddingY"] }, |
| |
| scrollSnapType: { |
| values: { |
| none: "none", |
| x: "x var(--scroll-snap-strictness)", |
| y: "y var(--scroll-snap-strictness)", |
| both: "both var(--scroll-snap-strictness)", |
| }, |
| }, |
| scrollSnapStrictness: { |
| values: ["mandatory", "proximity"], |
| transform: (v) => ({ "--scroll-snap-strictness": v }), |
| }, |
| scrollSnapMargin: { values: "spacing" }, |
| scrollSnapMarginTop: { values: "spacing" }, |
| scrollSnapMarginBottom: { values: "spacing" }, |
| scrollSnapMarginLeft: { values: "spacing" }, |
| scrollSnapMarginRight: { values: "spacing" }, |
| |
| listStylePosition: { shorthand: ["listStylePos"] }, |
| listStyleImage: { values: "assets", shorthand: ["listStyleImg"] }, |
| |
| position: { shorthand: ["pos"] }, |
| zIndex: { values: "zIndex" }, |
| inset: { values: "spacing" }, |
| insetInline: { values: "spacing", shorthand: ["insetX"] }, |
| insetBlock: { values: "spacing", shorthand: ["insetY"] }, |
| top: { values: "spacing" }, |
| insetBlockStart: { values: "spacing" }, |
| bottom: { values: "spacing" }, |
| insetBlockEnd: { values: "spacing" }, |
| left: { values: "spacing" }, |
| right: { values: "spacing" }, |
| insetInlineStart: { |
| values: "spacing", |
| shorthand: ["insetStart"], |
| }, |
| insetInlineEnd: { |
| values: "spacing", |
| shorthand: ["insetEnd"], |
| }, |
| |
| ring: { |
| transform(value) { |
| return { |
| "--ring-offset-shadow": `var(--ring-inset) 0 0 0 var(--ring-offset-width) var(--ring-offset-color)`, |
| "--ring-shadow": `var(--ring-inset) 0 0 0 calc(var(--ring-width) + var(--ring-offset-width)) var(--ring-color)`, |
| "--ring-width": value, |
| boxShadow: |
| "var(--ring-offset-shadow), var(--ring-shadow), var(--shadow, 0 0 #0000)", |
| } |
| }, |
| }, |
| ringColor: { |
| values: colorValues, |
| transform: createColorMixTransform("--ring-color"), |
| }, |
| ringOffset: { |
| transform: (value) => ({ "--ring-offset-width": value }), |
| }, |
| ringOffsetColor: { |
| values: colorValues, |
| transform: createColorMixTransform("--ring-offset-color"), |
| }, |
| ringInset: { |
| transform: (v) => ({ "--ring-inset": v }), |
| }, |
| |
| margin: { values: "spacing", shorthand: ["m"] }, |
| marginTop: { values: "spacing", shorthand: ["mt"] }, |
| marginBlockStart: { values: "spacing" }, |
| marginRight: { values: "spacing", shorthand: ["mr"] }, |
| marginBottom: { values: "spacing", shorthand: ["mb"] }, |
| marginBlockEnd: { values: "spacing" }, |
| marginLeft: { values: "spacing", shorthand: ["ml"] }, |
| marginInlineStart: { values: "spacing", shorthand: ["ms", "marginStart"] }, |
| marginInlineEnd: { values: "spacing", shorthand: ["me", "marginEnd"] }, |
| marginInline: { values: "spacing", shorthand: ["mx", "marginX"] }, |
| marginBlock: { values: "spacing", shorthand: ["my", "marginY"] }, |
| |
| padding: { values: "spacing", shorthand: ["p"] }, |
| paddingTop: { values: "spacing", shorthand: ["pt"] }, |
| paddingRight: { values: "spacing", shorthand: ["pr"] }, |
| paddingBottom: { values: "spacing", shorthand: ["pb"] }, |
| paddingBlockStart: { values: "spacing" }, |
| paddingBlockEnd: { values: "spacing" }, |
| paddingLeft: { values: "spacing", shorthand: ["pl"] }, |
| paddingInlineStart: { |
| values: "spacing", |
| shorthand: ["ps", "paddingStart"], |
| }, |
| paddingInlineEnd: { values: "spacing", shorthand: ["pe", "paddingEnd"] }, |
| paddingInline: { values: "spacing", shorthand: ["px", "paddingX"] }, |
| paddingBlock: { values: "spacing", shorthand: ["py", "paddingY"] }, |
| |
| textDecoration: { shorthand: ["textDecor"] }, |
| textDecorationColor: { |
| values: colorValues, |
| transform: createColorMixTransform("textDecorationColor"), |
| }, |
| textShadow: { values: "shadows" }, |
| |
| transform: { |
| transform: (value) => { |
| let v = value |
| if (value === "auto") { |
| v = `translateX(var(--translate-x, 0)) translateY(var(--translate-y, 0)) rotate(var(--rotate, 0)) scaleX(var(--scale-x, 1)) scaleY(var(--scale-y, 1)) skewX(var(--skew-x, 0)) skewY(var(--skew-y, 0))` |
| } |
| if (value === "auto-gpu") { |
| v = `translate3d(var(--translate-x, 0), var(--translate-y, 0), 0) rotate(var(--rotate, 0)) scaleX(var(--scale-x, 1)) scaleY(var(--scale-y, 1)) skewX(var(--skew-x, 0)) skewY(var(--skew-y, 0))` |
| } |
| return { transform: v } |
| }, |
| }, |
| skewX: { transform: (v) => ({ "--skew-x": deg(v) }) }, |
| skewY: { transform: (v) => ({ "--skew-y": deg(v) }) }, |
| scaleX: { transform: (v) => ({ "--scale-x": v }) }, |
| scaleY: { transform: (v) => ({ "--scale-y": v }) }, |
| scale: { |
| transform(value) { |
| if (value !== "auto") return { scale: value } |
| return { |
| scale: `var(--scale-x, 1) var(--scale-y, 1)`, |
| } |
| }, |
| }, |
| spaceXReverse: { |
| values: { type: "boolean" }, |
| transform(value) { |
| return { |
| "& > :not(style, [hidden]) ~ :not(style, [hidden])": { |
| "--space-x-reverse": value ? "1" : undefined, |
| }, |
| } |
| }, |
| }, |
| spaceX: { |
| property: "marginInlineStart", |
| values: "spacing", |
| transform: (v) => ({ |
| "& > :not(style, [hidden]) ~ :not(style, [hidden])": { |
| "--space-x-reverse": "0", |
| marginInlineStart: `calc(${v} * calc(1 - var(--space-x-reverse)))`, |
| marginInlineEnd: `calc(${v} * var(--space-x-reverse))`, |
| }, |
| }), |
| }, |
| spaceYReverse: { |
| values: { type: "boolean" }, |
| transform(value) { |
| return { |
| "& > :not(style, [hidden]) ~ :not(style, [hidden])": { |
| "--space-y-reverse": value ? "1" : undefined, |
| }, |
| } |
| }, |
| }, |
| spaceY: { |
| property: "marginTop", |
| values: "spacing", |
| transform: (v) => ({ |
| "& > :not(style, [hidden]) ~ :not(style, [hidden])": { |
| "--space-y-reverse": "0", |
| marginTop: `calc(${v} * calc(1 - var(--space-y-reverse)))`, |
| marginBottom: `calc(${v} * var(--space-y-reverse))`, |
| }, |
| }), |
| }, |
| rotate: { |
| transform(value) { |
| if (value !== "auto") return { rotate: deg(value) } |
| return { |
| rotate: `var(--rotate-x, 0) var(--rotate-y, 0) var(--rotate-z, 0)`, |
| } |
| }, |
| }, |
| rotateX: { |
| transform(value) { |
| return { "--rotate-x": deg(value) } |
| }, |
| }, |
| rotateY: { |
| transform(value) { |
| return { "--rotate-y": deg(value) } |
| }, |
| }, |
| |
| translate: { |
| transform(value) { |
| if (value !== "auto") return { translate: value } |
| return { |
| translate: `var(--translate-x) var(--translate-y)`, |
| } |
| }, |
| }, |
| translateX: { |
| values: "spacing", |
| transform: (v) => ({ "--translate-x": v }), |
| }, |
| translateY: { |
| values: "spacing", |
| transform: (v) => ({ "--translate-y": v }), |
| }, |
| |
| transition: { |
| values: [ |
| "all", |
| "common", |
| "colors", |
| "opacity", |
| "position", |
| "backgrounds", |
| "size", |
| "shadow", |
| "transform", |
| ], |
| transform(value) { |
| switch (value) { |
| case "all": |
| return createTransition("all") |
| case "position": |
| return createTransition( |
| "left, right, top, bottom, inset-inline, inset-block", |
| ) |
| case "colors": |
| return createTransition( |
| "color, background-color, border-color, text-decoration-color, fill, stroke", |
| ) |
| case "opacity": |
| return createTransition("opacity") |
| case "shadow": |
| return createTransition("box-shadow") |
| case "transform": |
| return createTransition("transform") |
| case "size": |
| return createTransition("width, height") |
| case "backgrounds": |
| return createTransition( |
| "background, background-color, background-image, background-position", |
| ) |
| case "common": |
| return createTransition( |
| "color, background-color, border-color, text-decoration-color, fill, stroke, opacity, box-shadow, transform, filter, backdrop-filter", |
| ) |
| default: |
| return { transition: value } |
| } |
| }, |
| }, |
| transitionDuration: { values: "durations" }, |
| transitionProperty: { |
| values: { |
| common: |
| "background-color, border-color, color, fill, stroke, opacity, box-shadow, translate, transform", |
| colors: "background-color, border-color, color, fill, stroke", |
| size: "width, height", |
| position: "left, right, top, bottom, inset-inline, inset-block", |
| background: |
| "background, background-color, background-image, background-position", |
| }, |
| }, |
| transitionTimingFunction: { values: "easings" }, |
| |
| animation: { values: "animations" }, |
| animationDuration: { values: "durations" }, |
| animationDelay: { values: "durations" }, |
| animationTimingFunction: { values: "easings" }, |
| |
| fontFamily: { values: "fonts" }, |
| fontSize: { values: "fontSizes" }, |
| fontWeight: { values: "fontWeights" }, |
| lineHeight: { values: "lineHeights" }, |
| letterSpacing: { values: "letterSpacings" }, |
| textIndent: { values: "spacing" }, |
| truncate: { |
| values: { type: "boolean" }, |
| transform(value) { |
| if (value === true) { |
| return { |
| overflow: "hidden", |
| textOverflow: "ellipsis", |
| whiteSpace: "nowrap", |
| } |
| } |
| return {} |
| }, |
| }, |
| lineClamp: { |
| transform(value) { |
| if (value === "none") { |
| return { |
| WebkitLineClamp: "unset", |
| } |
| } |
| return { |
| overflow: "hidden", |
| display: "-webkit-box", |
| WebkitLineClamp: value, |
| WebkitBoxOrient: "vertical", |
| textWrap: "wrap", |
| } |
| }, |
| }, |
| |
| srOnly: { |
| values: { type: "boolean" }, |
| transform(value) { |
| return srMapping[value] || {} |
| }, |
| }, |
| debug: { |
| values: { type: "boolean" }, |
| transform(value) { |
| if (!value) return {} |
| return { |
| outline: "1px solid blue !important", |
| "& > *": { |
| outline: "1px solid red !important", |
| }, |
| } |
| }, |
| }, |
| caretColor: { |
| values: colorValues, |
| transform: createColorMixTransform("caretColor"), |
| }, |
| cursor: { values: "cursor" }, |
| }, |
| }) |
|
|
| const srMapping: Record<string, any> = { |
| true: { |
| position: "absolute", |
| width: "1px", |
| height: "1px", |
| padding: "0", |
| margin: "-1px", |
| overflow: "hidden", |
| clip: "rect(0, 0, 0, 0)", |
| whiteSpace: "nowrap", |
| borderWidth: "0", |
| }, |
| false: { |
| position: "static", |
| width: "auto", |
| height: "auto", |
| padding: "0", |
| margin: "0", |
| overflow: "visible", |
| clip: "auto", |
| whiteSpace: "normal", |
| }, |
| } |
|
|
