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