1use std::collections::{HashMap, HashSet};
2
3use lightningcss::declaration::DeclarationBlock;
4use lightningcss::rules::CssRule;
5use lightningcss::stylesheet::{ParserFlags, ParserOptions, PrinterOptions, StyleSheet};
6use lightningcss::traits::ToCss;
7
8use crate::classes::normalize_utility_class_name;
9use crate::stats::{compute_atomic_stats, AtomicStats};
10use crate::tailwind::looks_like_tailwind_utility;
11
12const TAILWIND_PSEUDO_ELEMENTS: &[&str] = &[
13 "::-webkit-input-placeholder",
14 "::placeholder",
15 "::file-selector-button",
16 "::marker",
17 "::backdrop",
18 "::first-line",
19 "::first-letter",
20 "::selection",
21];
22
23fn printer_options() -> PrinterOptions<'static> {
24 PrinterOptions {
25 minify: false,
26 ..PrinterOptions::default()
27 }
28}
29
30fn parser_options<'i>() -> ParserOptions<'i> {
31 ParserOptions {
32 filename: String::from("tailwindcss-atomic.css"),
33 flags: ParserFlags::NESTING,
34 error_recovery: true,
35 ..ParserOptions::default()
36 }
37}
38
39pub fn hash_string(input: &str) -> String {
40 let mut hash: u64 = 5381;
41 for byte in input.bytes() {
42 hash = ((hash << 5).wrapping_add(hash)).wrapping_add(byte as u64);
43 }
44 format!("_{:06x}", hash & 0xFFFFFF)
45}
46
47fn to_css<T: ToCss>(value: &T) -> String {
48 value.to_css_string(printer_options()).unwrap_or_default()
49}
50
51fn has_tailwind_variant_escape(selector: &str) -> bool {
52 selector.contains("\\:")
53}
54
55fn is_document_or_theme_root_selector(selector: &str) -> bool {
56 let sel = selector.trim();
57 sel.starts_with("html")
58 || sel.starts_with("body")
59 || sel.starts_with(":root")
60 || sel.contains("[data-theme")
61}
62
63fn is_tailwind_space_or_divide_selector(selector: &str) -> bool {
64 let sel = selector.trim();
65 let bytes = sel.as_bytes();
66 if bytes.first() != Some(&b'.') {
67 return false;
68 }
69 let mut class_end = 1;
70 while class_end < bytes.len() {
71 let b = bytes[class_end];
72 if b == b'\\' {
73 class_end = skip_css_escape(bytes, class_end);
74 continue;
75 }
76 if matches!(b, b' ' | b'>' | b'+' | b'~') {
77 break;
78 }
79 class_end += 1;
80 }
81 let rest = sel[class_end..].trim_start();
82 rest == "> :not([hidden]) ~ :not([hidden])" || rest == ">:not([hidden])~:not([hidden])"
83}
84
85fn has_component_pseudo_element(selector: &str) -> bool {
86 if has_tailwind_variant_escape(selector) {
87 return false;
88 }
89 if selector.contains(":before") || selector.contains(":after") {
91 return true;
92 }
93 if !selector.contains("::") {
94 return false;
95 }
96 let mut stripped = selector.to_string();
97 for pseudo in TAILWIND_PSEUDO_ELEMENTS {
98 stripped = stripped.replace(pseudo, "");
99 }
100 stripped.contains("::")
101}
102
103fn has_non_utility_combinator(selector: &str) -> bool {
104 if is_tailwind_space_or_divide_selector(selector) {
105 return false;
106 }
107 let mut normalized = String::new();
108 let bytes = selector.as_bytes();
109 let mut i = 0;
110 while i < bytes.len() {
111 if bytes[i] == b'\\' {
112 i = skip_css_escape(bytes, i);
113 continue;
114 }
115 if bytes[i] == b'(' {
116 normalized.push_str("()");
117 while i < bytes.len() && bytes[i] != b')' {
118 if bytes[i] == b'\\' {
119 i = skip_css_escape(bytes, i);
120 continue;
121 }
122 i += 1;
123 }
124 if i < bytes.len() {
125 i += 1;
126 }
127 continue;
128 }
129 normalized.push(bytes[i] as char);
130 i += 1;
131 }
132 normalized
133 .chars()
134 .any(|ch| matches!(ch, ' ' | '>' | '+' | '~'))
135}
136
137fn skip_css_escape(bytes: &[u8], i: usize) -> usize {
138 if i < bytes.len() && bytes[i] == b'\\' {
139 (i + 2).min(bytes.len())
140 } else {
141 i
142 }
143}
144
145fn is_class_name_terminator(b: u8) -> bool {
146 matches!(
149 b,
150 b' ' | b'.' | b':' | b'#' | b'>' | b'+' | b'~' | b',' | b'['
151 )
152}
153
154fn scan_class_name_end(bytes: &[u8], mut i: usize) -> usize {
158 while i < bytes.len() {
159 if bytes[i] == b'\\' {
160 i = skip_css_escape(bytes, i);
161 continue;
162 }
163 if is_class_name_terminator(bytes[i]) {
164 break;
165 }
166 i += 1;
167 }
168 i
169}
170
171fn count_unescaped_classes(selector: &str) -> usize {
172 let bytes = selector.as_bytes();
173 let mut count = 0;
174 let mut i = 0;
175 while i < bytes.len() {
176 if bytes[i] == b'\\' {
177 i = skip_css_escape(bytes, i);
178 continue;
179 }
180 if bytes[i] == b'.' {
181 count += 1;
182 i = scan_class_name_end(bytes, i + 1);
183 continue;
184 }
185 i += 1;
186 }
187 count
188}
189
190fn split_comma_selectors(selector: &str) -> Vec<&str> {
194 let bytes = selector.as_bytes();
195 let mut parts = Vec::new();
196 let mut start = 0;
197 let mut i = 0;
198 let mut paren = 0i32;
199 let mut bracket = 0i32;
200 let mut quote: Option<u8> = None;
201
202 while i < bytes.len() {
203 let b = bytes[i];
204 if b == b'\\' {
205 i = skip_css_escape(bytes, i);
206 continue;
207 }
208 if let Some(q) = quote {
209 if b == q {
210 quote = None;
211 }
212 i += 1;
213 continue;
214 }
215 match b {
216 b'"' | b'\'' => {
217 quote = Some(b);
218 i += 1;
219 }
220 b'(' => {
221 paren += 1;
222 i += 1;
223 }
224 b')' => {
225 paren = paren.saturating_sub(1);
226 i += 1;
227 }
228 b'[' => {
229 bracket += 1;
230 i += 1;
231 }
232 b']' => {
233 bracket = bracket.saturating_sub(1);
234 i += 1;
235 }
236 b',' if paren == 0 && bracket == 0 => {
237 if let Some(part) = selector.get(start..i).map(str::trim).filter(|p| !p.is_empty())
238 {
239 parts.push(part);
240 }
241 i += 1;
242 start = i;
243 }
244 _ => i += 1,
245 }
246 }
247
248 if let Some(part) = selector.get(start..).map(str::trim).filter(|p| !p.is_empty()) {
249 parts.push(part);
250 }
251 parts
252}
253
254fn looks_like_css_module_class(class_name: &str) -> bool {
255 if !class_name.contains("__") {
256 return false;
257 }
258 if class_name.contains('\\') || class_name.contains('[') || class_name.contains(':') {
259 return false;
260 }
261 true
262}
263
264fn class_token_is_tailwind_utility(selector: &str) -> bool {
265 match first_class_in_selector(selector) {
266 Some((_, raw)) => {
267 if looks_like_css_module_class(&raw) {
268 return false;
269 }
270 looks_like_tailwind_utility(&raw)
271 }
272 None => false,
273 }
274}
275
276fn is_single_utility_selector(selector: &str) -> bool {
277 let sel = selector.trim();
278 if !sel.contains('.') {
279 return false;
280 }
281 if is_tailwind_space_or_divide_selector(sel) {
282 return class_token_is_tailwind_utility(sel);
283 }
284 if !has_tailwind_variant_escape(sel) {
285 if is_document_or_theme_root_selector(sel) {
286 return false;
287 }
288 if has_component_pseudo_element(sel) {
289 return false;
290 }
291 if has_non_utility_combinator(sel) {
292 return false;
293 }
294 if count_unescaped_classes(sel) != 1 {
295 return false;
296 }
297 }
298 class_token_is_tailwind_utility(sel)
299}
300
301pub fn is_utility_selector(selector: &str) -> bool {
302 let parts = split_comma_selectors(selector);
303 !parts.is_empty() && parts.iter().all(|part| is_single_utility_selector(part))
304}
305
306fn has_theme_custom_properties(block: &DeclarationBlock<'_>) -> bool {
307 block.iter().any(|(prop, important)| {
308 let css = prop
309 .to_css_string(important, printer_options())
310 .unwrap_or_default();
311 let name = css.split(':').next().unwrap_or("").trim();
312 name.starts_with("--") && !name.starts_with("--tw-")
313 })
314}
315
316fn first_class_in_selector(selector: &str) -> Option<(usize, String)> {
317 let bytes = selector.as_bytes();
318 let mut i = 0;
319 while i < bytes.len() {
320 if bytes[i] == b'\\' {
321 i = skip_css_escape(bytes, i);
322 continue;
323 }
324 if bytes[i] == b'.' {
325 let start = i;
326 let class_start = i + 1;
327 i = scan_class_name_end(bytes, class_start);
328 let raw = selector.get(class_start..i.min(selector.len()))?;
329 if raw.is_empty() {
330 return None;
331 }
332 return Some((start, raw.to_string()));
333 }
334 i += 1;
335 }
336 None
337}
338
339fn replace_first_class(selector: &str, new_class: &str) -> String {
340 if let Some((dot_at, raw)) = first_class_in_selector(selector) {
341 let rest_at = dot_at.saturating_add(1).saturating_add(raw.len());
342 let prefix = selector.get(..dot_at).unwrap_or("");
343 let suffix = selector.get(rest_at..).unwrap_or("");
344 let mut out = String::with_capacity(prefix.len() + new_class.len() + suffix.len() + 1);
345 out.push_str(prefix);
346 out.push('.');
347 out.push_str(new_class);
348 out.push_str(suffix);
349 return out;
350 }
351 format!(".{new_class}")
352}
353
354fn collect_decls(block: &DeclarationBlock<'_>) -> Vec<String> {
355 let mut collected = Vec::new();
356 for (prop, important) in block.iter() {
357 if let Ok(css) = prop.to_css_string(important, printer_options()) {
358 if !css.is_empty() {
359 collected.push(css);
360 }
361 }
362 }
363 collected
364}
365
366fn wrap_at_rule(kind: &str, prelude: &str, inner: &str) -> String {
367 if inner.trim().is_empty() {
368 return String::new();
369 }
370 if prelude.is_empty() {
371 format!("@{kind} {{\n{inner}\n}}\n")
372 } else {
373 format!("@{kind} {prelude} {{\n{inner}\n}}\n")
374 }
375}
376
377fn resolve_nested_selector(parent: Option<&str>, nested: &str) -> String {
378 let nested = nested.trim();
379 let Some(parent) = parent.map(str::trim).filter(|sel| !sel.is_empty()) else {
380 return nested.to_string();
381 };
382 if nested.is_empty() || nested == "&" {
383 return parent.to_string();
384 }
385 if nested.contains('&') {
386 return nested.replace('&', parent);
387 }
388 if nested.starts_with(':') || nested.starts_with('[') {
389 return format!("{parent}{nested}");
390 }
391 nested.to_string()
392}
393
394fn has_declarations(block: &DeclarationBlock<'_>) -> bool {
395 block.iter().next().is_some()
396}
397
398struct EmitCtx<'a> {
399 class_map: &'a mut HashMap<String, Vec<String>>,
400 seen: &'a mut HashSet<String>,
401 component_classes: &'a HashSet<String>,
402 changed: bool,
403}
404
405fn collect_component_classes(rules: &[CssRule<'_>], out: &mut HashSet<String>) {
406 for rule in rules {
407 match rule {
408 CssRule::Style(style) => {
409 let selector = to_css(&style.selectors);
410 if has_component_pseudo_element(&selector) {
411 if let Some((_, raw)) = first_class_in_selector(&selector) {
412 let name = normalize_utility_class_name(&raw);
413 if !name.is_empty() {
414 out.insert(name);
415 }
416 }
417 }
418 collect_component_classes(&style.rules.0, out);
419 }
420 CssRule::Media(media) => collect_component_classes(&media.rules.0, out),
421 CssRule::Supports(supports) => collect_component_classes(&supports.rules.0, out),
422 CssRule::Container(container) => collect_component_classes(&container.rules.0, out),
423 CssRule::LayerBlock(layer) => collect_component_classes(&layer.rules.0, out),
424 CssRule::StartingStyle(starting) => collect_component_classes(&starting.rules.0, out),
425 _ => {}
426 }
427 }
428}
429
430fn emit_style_rule(
431 selector: &str,
432 block: &DeclarationBlock<'_>,
433 nested_empty: bool,
434 ctx: &mut EmitCtx<'_>,
435) -> String {
436 if !nested_empty || has_theme_custom_properties(block) || !is_utility_selector(selector) {
437 return String::new();
438 }
439
440 let Some((_, raw_class)) = first_class_in_selector(selector) else {
441 return String::new();
442 };
443 let original = normalize_utility_class_name(&raw_class);
444 if original.is_empty() || ctx.component_classes.contains(&original) {
445 return String::new();
446 }
447
448 let decls = collect_decls(block);
449 if decls.is_empty() {
450 return String::new();
451 }
452
453 let mut hashes = Vec::new();
454 let mut css = String::new();
455 for decl in decls {
456 let hash = hash_string(&format!("{original}\0{decl}"));
457 let next_selector = replace_first_class(selector, &hash);
458 let rule = format!("{next_selector} {{ {decl} }}");
459 hashes.push(hash);
460 if ctx.seen.insert(rule.clone()) {
461 css.push_str(&rule);
462 css.push('\n');
463 }
464 }
465
466 if hashes.is_empty() {
467 return String::new();
468 }
469
470 let entry = ctx.class_map.entry(original).or_default();
471 for hash in hashes {
472 if !entry.contains(&hash) {
473 entry.push(hash);
474 }
475 }
476 ctx.changed = true;
477 css
478}
479
480fn emit_at_rule_or_original(
481 kind: &str,
482 prelude: &str,
483 inner: String,
484 original: &CssRule<'_>,
485 out: &mut String,
486) {
487 if inner.trim().is_empty() {
488 out.push_str(&to_css(original));
489 out.push('\n');
490 return;
491 }
492 out.push_str(&wrap_at_rule(kind, prelude, &inner));
493}
494
495fn emit_rules(
496 rules: &[CssRule<'_>],
497 parent_selector: Option<&str>,
498 ctx: &mut EmitCtx<'_>,
499) -> String {
500 let mut out = String::new();
501 for rule in rules {
502 match rule {
503 CssRule::LayerBlock(layer) => {
504 out.push_str(&emit_rules(&layer.rules.0, parent_selector, ctx));
505 }
506 CssRule::LayerStatement(_) => {}
507 CssRule::Media(media) => {
508 let inner = emit_rules(&media.rules.0, parent_selector, ctx);
509 emit_at_rule_or_original("media", &to_css(&media.query), inner, rule, &mut out);
510 }
511 CssRule::Supports(supports) => {
512 let inner = emit_rules(&supports.rules.0, parent_selector, ctx);
513 emit_at_rule_or_original(
514 "supports",
515 &to_css(&supports.condition),
516 inner,
517 rule,
518 &mut out,
519 );
520 }
521 CssRule::Container(container) => {
522 let prelude = match (&container.name, &container.condition) {
523 (Some(name), Some(condition)) => {
524 format!("{} {}", to_css(name), to_css(condition))
525 }
526 (Some(name), None) => to_css(name),
527 (None, Some(condition)) => to_css(condition),
528 (None, None) => String::new(),
529 };
530 let inner = emit_rules(&container.rules.0, parent_selector, ctx);
531 emit_at_rule_or_original("container", prelude.trim(), inner, rule, &mut out);
532 }
533 CssRule::StartingStyle(starting) => {
534 let inner = emit_rules(&starting.rules.0, parent_selector, ctx);
535 emit_at_rule_or_original("starting-style", "", inner, rule, &mut out);
536 }
537 CssRule::NestedDeclarations(decls) => {
538 if let Some(selector) = parent_selector {
539 let atomic = emit_style_rule(selector, &decls.declarations, true, ctx);
540 if atomic.is_empty() {
541 out.push_str(&to_css(rule));
542 out.push('\n');
543 } else {
544 out.push_str(&atomic);
545 }
546 } else {
547 out.push_str(&to_css(rule));
548 out.push('\n');
549 }
550 }
551 CssRule::Style(style) => {
552 let raw_selector = to_css(&style.selectors);
553 let selector = resolve_nested_selector(parent_selector, &raw_selector);
554 let nested_empty = style.rules.0.is_empty();
555 let theme_tokens = has_theme_custom_properties(&style.declarations);
556 let utility = is_utility_selector(&selector)
557 && first_class_in_selector(&selector)
558 .map(|(_, raw)| {
559 !ctx.component_classes
560 .contains(&normalize_utility_class_name(&raw))
561 })
562 .unwrap_or(true);
563
564 if (!utility || theme_tokens) && !nested_empty {
566 out.push_str(&to_css(style));
567 out.push('\n');
568 continue;
569 }
570
571 let mut emitted = String::new();
572 if has_declarations(&style.declarations) {
573 emitted.push_str(&emit_style_rule(
574 &selector,
575 &style.declarations,
576 true,
577 ctx,
578 ));
579 }
580 if !nested_empty {
581 emitted.push_str(&emit_rules(&style.rules.0, Some(&selector), ctx));
583 }
584
585 if !emitted.is_empty() {
586 out.push_str(&emitted);
587 } else {
588 out.push_str(&to_css(style));
589 out.push('\n');
590 }
591 }
592 CssRule::Ignored => {}
593 other => {
594 out.push_str(&to_css(other));
595 out.push('\n');
596 }
597 }
598 }
599 out
600}
601
602pub struct AtomicOutput {
603 pub class_map: HashMap<String, String>,
604 pub css: String,
605 pub css_rules: Vec<String>,
606 pub changed: bool,
607 pub stats: AtomicStats,
608}
609
610fn elapsed_micros(started: Option<std::time::Instant>) -> u64 {
611 started
612 .map(|start| start.elapsed().as_micros().min(u128::from(u64::MAX)) as u64)
613 .unwrap_or(0)
614}
615
616pub fn atomicize_stylesheet(raw_css: &str) -> Result<AtomicOutput, String> {
617 let started = if cfg!(target_arch = "wasm32") {
619 None
620 } else {
621 Some(std::time::Instant::now())
622 };
623 let stylesheet = StyleSheet::parse(raw_css, parser_options())
624 .map_err(|error| format!("Error parseando CSS: {error:?}"))?;
625
626 let mut class_lists: HashMap<String, Vec<String>> = HashMap::new();
627 let mut seen = HashSet::new();
628 let mut component_classes = HashSet::new();
629 collect_component_classes(&stylesheet.rules.0, &mut component_classes);
630 let mut ctx = EmitCtx {
631 class_map: &mut class_lists,
632 seen: &mut seen,
633 component_classes: &component_classes,
634 changed: false,
635 };
636 let css = emit_rules(&stylesheet.rules.0, None, &mut ctx);
637 let changed = ctx.changed;
638
639 let css_rules: Vec<String> = css
640 .lines()
641 .map(str::trim)
642 .filter(|line| line.starts_with("._") || line.contains("._"))
643 .filter(|line| line.contains('{'))
644 .map(ToString::to_string)
645 .collect();
646
647 let class_map = class_lists
648 .into_iter()
649 .map(|(key, hashes)| {
650 let mut unique = Vec::new();
651 for hash in hashes {
652 if !unique.contains(&hash) {
653 unique.push(hash);
654 }
655 }
656 (key, unique.join(" "))
657 })
658 .collect();
659
660 let elapsed_us = elapsed_micros(started);
661 let stats = compute_atomic_stats(raw_css, &class_map, &css, changed, elapsed_us);
662
663 Ok(AtomicOutput {
664 class_map,
665 css,
666 css_rules,
667 changed,
668 stats,
669 })
670}
671
672#[cfg(test)]
673mod tests {
674 use super::*;
675
676 #[test]
677 fn atomicizes_bare_rounded() {
678 let out = atomicize_stylesheet(
679 ".rounded { border-radius: 0.25rem } .flex { display: flex }",
680 )
681 .unwrap();
682 assert!(out.class_map.get("rounded").is_some(), "css={}", out.css);
683 assert!(out.class_map.get("flex").is_some());
684 assert!(!out.css.contains(".rounded {"));
685 assert!(!out.css.contains(".flex {"));
686 }
687
688 #[test]
689 fn keeps_hover_on_the_selector() {
690 let out =
691 atomicize_stylesheet(".hover\\:bg-red-500:hover { background-color: red }").unwrap();
692 let hashed = out.class_map.get("hover:bg-red-500").expect("mapped");
693 assert!(out.css.contains(&format!(".{hashed}:hover")));
694 assert!(!out.css.contains(".hover\\:bg-red-500"));
695 }
696
697 #[test]
698 fn atomicizes_data_and_aria_attribute_variants() {
699 let out = atomicize_stylesheet(
700 r#"
701.data-\[active\=true\]\:font-medium[data-active=true] {
702 --tw-font-weight: var(--font-weight-medium);
703 font-weight: var(--font-weight-medium);
704}
705.data-\[state\=open\]\:flex[data-state=open] { display: flex }
706.aria-selected\:bg-red-500[aria-selected="true"] { background-color: red }
707.open\:hidden[open] { display: none }
708.flex { display: flex }
709"#,
710 )
711 .unwrap();
712
713 let data_font = out
714 .class_map
715 .get("data-[active=true]:font-medium")
716 .expect("data-[active=true]:font-medium");
717 let data_flex = out
718 .class_map
719 .get("data-[state=open]:flex")
720 .expect("data-[state=open]:flex");
721 assert!(out.class_map.get("aria-selected:bg-red-500").is_some());
722 assert!(out.class_map.get("open:hidden").is_some());
723 assert!(out.class_map.get("flex").is_some());
724
725 let font_hash = data_font.split_whitespace().next().expect("hash");
726 let flex_hash = data_flex.split_whitespace().next().expect("hash");
727 assert!(
728 out.css.contains(&format!(".{font_hash}[data-active=true]"))
729 || out.css.contains(&format!(".{font_hash}[data-active=\"true\"]")),
730 "expected hashed data-active suffix, css={}",
731 out.css
732 );
733 assert!(
734 out.css.contains(&format!(".{flex_hash}[data-state=open]"))
735 || out.css.contains(&format!(".{flex_hash}[data-state=\"open\"]")),
736 "expected hashed data-state suffix, css={}",
737 out.css
738 );
739 assert!(!out.css.contains(".data-\\[active"));
740 assert!(!out.css.contains(".data-\\[state"));
741
742 let rewritten = crate::rewrite_class_string(
743 "data-[active=true]:font-medium flex data-[state=open]:flex",
744 &out.class_map,
745 );
746 assert!(rewritten.contains(font_hash));
747 assert!(rewritten.contains(flex_hash));
748 assert!(!rewritten.contains("data-[active=true]:font-medium"));
749 assert!(!rewritten.contains("data-[state=open]:flex"));
750 }
751
752 #[test]
753 fn keeps_space_combinators() {
754 let out = atomicize_stylesheet(
755 ".space-y-4 > :not([hidden]) ~ :not([hidden]) { margin-top: 1rem }",
756 )
757 .unwrap();
758 let hashed = out.class_map.get("space-y-4").expect("mapped");
759 assert!(
760 out.css
761 .contains(&format!(".{hashed} > :not([hidden]) ~ :not([hidden])"))
762 );
763 }
764
765 #[test]
766 fn does_not_atomicize_css_module_locals() {
767 let out = atomicize_stylesheet(
768 ".Nexi_svg__def34 { display: block; width: 100% } .flex { display: flex }",
769 )
770 .unwrap();
771 assert!(out.css.contains(".Nexi_svg__def34"));
772 assert!(out.css.contains("display: block"));
773 assert!(out.class_map.get("Nexi_svg__def34").is_none());
774 assert!(out.class_map.get("flex").is_some());
775 assert!(!out.css.contains(".flex"));
776 }
777
778 #[test]
779 fn still_atomicizes_arbitrary_values_that_contain_underscores() {
780 let out = atomicize_stylesheet(".w-\\[1fr__2fr\\] { width: 1fr }").unwrap();
781 assert!(out.changed);
782 assert!(out.class_map.len() >= 1);
783 assert!(!out.css.contains("1fr__2fr") || out.css.contains("._"));
784 }
785
786 #[test]
787 fn does_not_atomicize_theme_tokens() {
788 let out = atomicize_stylesheet(
789 ".pokerenchile { --color-red-600: #bc0000 } .flex { display: flex }",
790 )
791 .unwrap();
792 assert!(out.css.contains(".pokerenchile"));
793 assert!(out.class_map.get("pokerenchile").is_none());
794 assert!(out.class_map.get("flex").is_some());
795 }
796
797 #[test]
798 fn keeps_responsive_variants_inside_media() {
799 let out = atomicize_stylesheet(
800 ".top-0 { top: 0 } @media (min-width: 640px) { .sm\\:top-0 { top: 0 } }",
801 )
802 .unwrap();
803 let base = out.class_map.get("top-0").expect("base");
804 let sm = out.class_map.get("sm:top-0").expect("sm");
805 assert_ne!(base, sm);
806 assert!(out.css.contains("@media"));
807 assert!(out.css.contains(&format!(".{sm}")));
808 }
809
810 #[test]
811 fn atomicizes_tailwind_v4_nested_breakpoint_variants() {
812 let out = atomicize_stylesheet(
813 r#"
814.hidden { display: none }
815.items-center { align-items: center }
816.gap-8 { gap: 2rem }
817.lg\:flex {
818 @media (width >= 64rem) {
819 display: flex;
820 }
821}
822"#,
823 )
824 .unwrap();
825
826 let hidden = out.class_map.get("hidden").expect("hidden");
827 let lg_flex = out.class_map.get("lg:flex").expect("lg:flex");
828 assert_ne!(hidden, lg_flex);
829 assert!(out.css.contains("@media"));
830 assert!(out.css.contains(&format!(".{lg_flex}")));
831 assert!(out.css.contains("display: flex"));
832 assert!(!out.css.contains(".lg\\:flex"));
833 assert!(!out.css.contains(".hidden {"));
834 }
835
836 #[test]
837 fn atomicizes_tailwind_v4_nested_hover() {
838 let out = atomicize_stylesheet(
839 r#".hover\:bg-red-500 { &:hover { background-color: red; } }"#,
840 )
841 .unwrap();
842 let hashed = out.class_map.get("hover:bg-red-500").expect("hover");
843 assert!(out.css.contains(&format!(".{hashed}:hover")));
844 assert!(!out.css.contains(".hover\\:bg-red-500"));
845 }
846
847 #[test]
848 fn atomicizes_before_and_after_pseudo_elements() {
849 let out = atomicize_stylesheet(
850 r#"
851.before\:block::before { content: var(--tw-content); display: block }
852.after\:content-\[\'\'\]::after { content: var(--tw-content); content: "" }
853.before\:absolute { &::before { content: var(--tw-content); position: absolute } }
854.after\:inset-0 { &::after { content: var(--tw-content); inset: 0px } }
855"#,
856 )
857 .unwrap();
858
859 let first_hash = |key: &str| {
860 out.class_map
861 .get(key)
862 .expect(key)
863 .split_whitespace()
864 .next()
865 .expect("hash")
866 };
867
868 let before_block = first_hash("before:block");
869 let after_content = first_hash("after:content-['']");
870 let before_abs = first_hash("before:absolute");
871 let after_inset = first_hash("after:inset-0");
872
873 assert!(
874 out.css.contains(&format!(".{before_block}:before")),
875 "flat before:block css: {}",
876 out.css
877 );
878 assert!(
879 out.css.contains(&format!(".{after_content}:after")),
880 "flat after:content css: {}",
881 out.css
882 );
883 assert!(
884 out.css.contains(&format!(".{before_abs}:before")),
885 "nested before:absolute css: {}",
886 out.css
887 );
888 assert!(
889 out.css.contains(&format!(".{after_inset}:after")),
890 "nested after:inset-0 css: {}",
891 out.css
892 );
893 assert!(!out.css.contains(".before\\:block"));
894 assert!(!out.css.contains(".after\\:content-"));
895 assert!(!out.css.contains(".before\\:absolute"));
896 }
897
898 #[test]
899 fn atomicizes_nested_lg_hover_flex() {
900 let out = atomicize_stylesheet(
901 r#"
902.lg\:hover\:flex {
903 @media (width >= 64rem) {
904 &:hover {
905 display: flex;
906 }
907 }
908}
909"#,
910 )
911 .unwrap();
912 let hashed = out.class_map.get("lg:hover:flex").expect("lg:hover:flex");
913 assert!(out.css.contains("@media"));
914 assert!(out.css.contains(&format!(".{hashed}:hover")));
915 assert!(out.css.contains("display: flex"));
916 }
917
918 #[test]
919 fn atomicizes_lg_flex_inside_media_range_query() {
920 let out = atomicize_stylesheet(
921 r#"
922.hidden { display: none }
923@media (width >= 64rem) {
924 .lg\:flex { display: flex }
925}
926"#,
927 )
928 .unwrap();
929
930 let lg_flex = out.class_map.get("lg:flex").expect("lg:flex");
931 assert!(out.css.contains("@media"));
932 assert!(out.css.contains(&format!(".{lg_flex}")));
933 assert!(out.css.contains("display: flex"));
934 }
935
936 #[test]
937 fn flattens_layers() {
938 let out = atomicize_stylesheet("@layer utilities { .flex { display: flex } }").unwrap();
939 assert!(!out.css.contains("@layer"));
940 assert!(out.class_map.get("flex").is_some());
941 }
942
943 #[test]
944 fn preserves_theme_inline_custom_variant_and_oklch() {
945 let out = atomicize_stylesheet(
946 r#"
947@custom-variant dark (&:is(.dark *));
948@theme inline {
949 --color-background: var(--background);
950 --color-primary: var(--primary);
951}
952:root {
953 --background: oklch(1 0 0);
954 --primary: oklch(0.21 0.006 285.885);
955}
956.dark {
957 --background: oklch(0.141 0.005 285.823);
958 --primary: oklch(0.92 0.004 286.32);
959}
960.bg-background { background-color: var(--background); }
961.bg-primary { background-color: var(--primary); }
962.flex { display: flex; }
963"#,
964 )
965 .unwrap();
966
967 assert!(out.css.contains("@theme inline"));
968 assert!(out.css.contains("--color-background: var(--background)"));
969 assert!(out.css.contains("@custom-variant dark"));
970 assert!(out.css.contains(":root"));
971 assert!(out.css.contains("oklch"));
972 assert!(out.css.contains(".dark"));
973 assert!(out.class_map.get("flex").is_some());
974 assert!(out.class_map.get("bg-background").is_some());
975 assert!(out.class_map.get("dark").is_none());
976 }
977
978 #[test]
979 fn escaped_commas_in_arbitrary_values_do_not_panic() {
980 let cases = [
981 (".flex{display:flex}", "flex"),
982 (".w-\\[calc\\(100px\\)\\]{width:calc(100px)}", "w-[calc(100px)]"),
983 (".\\[color\\:red\\]{color:red}", "[color:red]"),
984 (
985 ".transition-\\[color\\,box-shadow\\]{transition-property:color,box-shadow}",
986 "transition-[color,box-shadow]",
987 ),
988 (
989 ".grid-cols-\\[repeat\\(auto-fill\\,minmax\\(220px\\,1fr\\)\\)\\]{grid-template-columns:repeat(auto-fill,minmax(220px,1fr))}",
990 "grid-cols-[repeat(auto-fill,minmax(220px,1fr))]",
991 ),
992 (
993 ".\\[transition-timing-function\\:cubic-bezier\\(0\\.34\\,1\\.56\\,0\\.64\\,1\\)\\]{transition-timing-function:cubic-bezier(0.34,1.56,0.64,1)}",
994 "[transition-timing-function:cubic-bezier(0.34,1.56,0.64,1)]",
995 ),
996 (
997 ".sm\\:grid-cols-\\[3rem_minmax\\(0\\,1fr\\)_7rem\\]{grid-template-columns:3rem minmax(0,1fr) 7rem}",
998 "sm:grid-cols-[3rem_minmax(0,1fr)_7rem]",
999 ),
1000 (
1001 ".\\[\\&\\:hover\\>svg\\]\\:drop-shadow-\\[0_0_6px_rgba\\(250\\,204\\,21\\,0\\.4\\)\\]{filter:drop-shadow(0 0 6px rgba(250,204,21,.4))}",
1002 "[&:hover>svg]:drop-shadow-[0_0_6px_rgba(250,204,21,0.4)]",
1003 ),
1004 ];
1005 for (css, key) in cases {
1006 let out = atomicize_stylesheet(css).unwrap_or_else(|e| panic!("failed {css}: {e}"));
1007 assert!(
1008 out.class_map.contains_key(key),
1009 "missing {key} in {:?} for {css}",
1010 out.class_map.keys().collect::<Vec<_>>()
1011 );
1012 assert!(out.changed, "expected change for {css}");
1013 }
1014
1015 let custom = atomicize_stylesheet(".a\\,b{color:red}").unwrap();
1016 assert!(
1017 custom.class_map.get("a,b").is_none(),
1018 "escaped-comma custom class must not be hashed"
1019 );
1020 assert!(custom.css.contains(".a\\,b") || custom.css.contains("a\\,b"));
1021 }
1022
1023 #[test]
1024 fn preserves_custom_hyphenated_component_classes() {
1025 let out = atomicize_stylesheet(
1026 r#"
1027.header-signin { color: red }
1028.btn-notch { display: flex }
1029.eye-line { width: 1px }
1030.flex { display: flex }
1031.p-4 { padding: 1rem }
1032.items-center { align-items: center }
1033.bg-revamp-primary-default { background-color: var(--x) }
1034.before\:content-\[\'\'\]::before { content: var(--tw-content); content: "" }
1035"#,
1036 )
1037 .unwrap();
1038
1039 assert!(out.css.contains(".header-signin"));
1040 assert!(out.css.contains(".btn-notch"));
1041 assert!(out.css.contains(".eye-line"));
1042 assert!(out.class_map.get("header-signin").is_none());
1043 assert!(out.class_map.get("btn-notch").is_none());
1044 assert!(out.class_map.get("eye-line").is_none());
1045
1046 assert!(out.class_map.get("flex").is_some());
1047 assert!(out.class_map.get("p-4").is_some());
1048 assert!(out.class_map.get("items-center").is_some());
1049 assert!(out.class_map.get("bg-revamp-primary-default").is_some());
1050 assert!(out.class_map.get("before:content-['']").is_some());
1051 assert!(!out.css.contains(".flex {"));
1052 assert!(!out.css.contains(".p-4 {"));
1053 }
1054
1055 #[test]
1056 fn preserves_component_base_when_pseudo_elements_exist() {
1057 let out = atomicize_stylesheet(
1058 r#"
1059.header-signin {
1060 position: relative;
1061 isolation: isolate;
1062 background-color: var(--primary);
1063}
1064.header-signin::before {
1065 content: "";
1066 position: absolute;
1067}
1068.header-signin::after {
1069 content: "";
1070}
1071.flex { display: flex }
1072"#,
1073 )
1074 .unwrap();
1075
1076 assert!(out.css.contains(".header-signin"));
1077 assert!(out.css.contains(".header-signin:before") || out.css.contains(".header-signin::before"));
1078 assert!(out.class_map.get("header-signin").is_none());
1079 assert!(out.class_map.get("flex").is_some());
1080 assert!(!out.css.contains(".flex {"));
1081 }
1082
1083 #[test]
1084 fn atomicizes_supports_color_mix_arbitrary_opacity() {
1085 let out = atomicize_stylesheet(
1086 r#"
1087@supports (color:color-mix(in lab,red,red)) {
1088 .from-primary\/\[0\.05\] {
1089 --tw-gradient-from: color-mix(in oklab, var(--primary) 5%, transparent);
1090 }
1091}
1092"#,
1093 )
1094 .unwrap();
1095
1096 assert!(
1097 out.class_map.get("from-primary/[0.05]").is_some(),
1098 "css={}\nkeys={:?}",
1099 out.css,
1100 out.class_map.keys().collect::<Vec<_>>()
1101 );
1102 assert!(out.css.contains("@supports"), "css={}", out.css);
1103 assert!(
1104 out.css.contains("color-mix") && out.css.contains("--tw-gradient-from"),
1105 "css={}",
1106 out.css
1107 );
1108 assert!(
1109 !out.css.contains(".from-primary"),
1110 "original selector leaked: {}",
1111 out.css
1112 );
1113 let hashed = out.class_map.get("from-primary/[0.05]").unwrap();
1114 assert!(out.css.contains(&format!(".{hashed}")));
1115
1116 let rewritten = crate::classes::rewrite_class_string(
1117 "bg-gradient-to-b from-primary/[0.05] to-transparent",
1118 &out.class_map,
1119 );
1120 assert!(
1121 rewritten.contains(hashed.split_whitespace().next().unwrap()),
1122 "rewritten={rewritten}"
1123 );
1124 assert!(!rewritten.contains("from-primary/[0.05]"));
1125 }
1126}