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