<_>>();
+
+ if candidates != expected {
+ dbg!(&candidates, &expected);
+ panic!("Extracted candidates do not match expected candidates");
+ }
+ }
+
+ #[cfg(test)]
+ fn test_extract_contains(input: &str, expected: Vec<&str>) {
use crate::extractor::{Extracted, Extractor};
let input = input.as_bytes();
@@ -46,7 +72,7 @@ pub trait PreProcessor: Sized + Default {
// Ensure all items are present in the candidates.
let mut missing = vec![];
- for item in &items {
+ for item in &expected {
if !candidates.contains(item) {
missing.push(item);
}
diff --git a/crates/oxide/src/extractor/pre_processors/pug.rs b/crates/oxide/src/extractor/pre_processors/pug.rs
index 7b44fcf5be04..70dfe5683197 100644
--- a/crates/oxide/src/extractor/pre_processors/pug.rs
+++ b/crates/oxide/src/extractor/pre_processors/pug.rs
@@ -15,7 +15,7 @@ impl PreProcessor for Pug {
let mut bracket_stack = BracketStack::default();
while cursor.pos < len {
- match cursor.curr {
+ match cursor.curr() {
// Only replace `.` with a space if it's not surrounded by numbers. E.g.:
//
// ```diff
@@ -43,7 +43,7 @@ impl PreProcessor for Pug {
// digit.
// E.g.: `bg-red-500.2xl:flex`
// ^^^
- if cursor.prev.is_ascii_digit() && cursor.next.is_ascii_digit() {
+ if cursor.prev().is_ascii_digit() && cursor.next().is_ascii_digit() {
let mut next_cursor = cursor.clone();
next_cursor.advance();
@@ -68,17 +68,17 @@ impl PreProcessor for Pug {
//
// However, we also need to make sure that we keep the parens that are part of the
// utility class. E.g.: `bg-(--my-color)`.
- b'(' if bracket_stack.is_empty() && !matches!(cursor.prev, b'-' | b'/') => {
+ b'(' if bracket_stack.is_empty() && !matches!(cursor.prev(), b'-' | b'/') => {
result[cursor.pos] = b' ';
- bracket_stack.push(cursor.curr);
+ bracket_stack.push(cursor.curr());
}
b'(' | b'[' | b'{' => {
- bracket_stack.push(cursor.curr);
+ bracket_stack.push(cursor.curr());
}
b')' | b']' | b'}' if !bracket_stack.is_empty() => {
- bracket_stack.pop(cursor.curr);
+ bracket_stack.pop(cursor.curr());
}
// Consume everything else
diff --git a/crates/oxide/src/extractor/pre_processors/ruby.rs b/crates/oxide/src/extractor/pre_processors/ruby.rs
index c94bd945f56e..1f2221414ff4 100644
--- a/crates/oxide/src/extractor/pre_processors/ruby.rs
+++ b/crates/oxide/src/extractor/pre_processors/ruby.rs
@@ -68,7 +68,8 @@ impl PreProcessor for Ruby {
}
let body = &content_as_str[body_start..body_end];
- let replaced = pre_process_input(body.as_bytes(), &lang.to_ascii_lowercase());
+ let replaced =
+ pre_process_input(body.as_bytes().to_vec(), &lang.to_ascii_lowercase());
result.replace_range(body_start..body_end, replaced);
break;
@@ -77,12 +78,12 @@ impl PreProcessor for Ruby {
// Ruby extraction
while cursor.pos < len {
- match cursor.curr {
+ match cursor.curr() {
b'"' => {
cursor.advance();
while cursor.pos < len {
- match cursor.curr {
+ match cursor.curr() {
// Escaped character, skip ahead to the next character
b'\\' => cursor.advance_twice(),
@@ -102,7 +103,7 @@ impl PreProcessor for Ruby {
cursor.advance();
while cursor.pos < len {
- match cursor.curr {
+ match cursor.curr() {
// Escaped character, skip ahead to the next character
b'\\' => cursor.advance_twice(),
@@ -119,12 +120,16 @@ impl PreProcessor for Ruby {
}
// Replace comments in Ruby files
- b'#' => {
+ //
+ // Except for strict locals, these are defined in a `<%# locals: … %>`. Checking if
+ // the comment is preceded by a `%` should be enough without having to perform more
+ // parsing logic. Worst case we _do_ scan a few comments.
+ b'#' if !matches!(cursor.prev(), b'%') => {
result[cursor.pos] = b' ';
cursor.advance();
while cursor.pos < len {
- match cursor.curr {
+ match cursor.curr() {
// End of the comment
b'\n' => break,
@@ -144,7 +149,7 @@ impl PreProcessor for Ruby {
}
// Looking for `%w`, `%W`, or `%p`
- if cursor.curr != b'%' || !matches!(cursor.next, b'w' | b'W' | b'p') {
+ if cursor.curr() != b'%' || !matches!(cursor.next(), b'w' | b'W' | b'p') {
cursor.advance();
continue;
}
@@ -152,7 +157,7 @@ impl PreProcessor for Ruby {
cursor.advance_twice();
// Boundary character
- let boundary = match cursor.curr {
+ let boundary = match cursor.curr() {
b'[' => b']',
b'(' => b')',
b'{' => b'}',
@@ -173,11 +178,11 @@ impl PreProcessor for Ruby {
cursor.advance();
while cursor.pos < len {
- match cursor.curr {
+ match cursor.curr() {
// Skip escaped characters
b'\\' => {
// Use backslash to embed spaces in the strings.
- if cursor.next == b' ' {
+ if cursor.next() == b' ' {
result[cursor.pos] = b' ';
}
@@ -186,19 +191,19 @@ impl PreProcessor for Ruby {
// Start of a nested bracket
b'[' | b'(' | b'{' => {
- bracket_stack.push(cursor.curr);
+ bracket_stack.push(cursor.curr());
}
// End of a nested bracket
b']' | b')' | b'}' if !bracket_stack.is_empty() => {
- if !bracket_stack.pop(cursor.curr) {
+ if !bracket_stack.pop(cursor.curr()) {
// Unbalanced
cursor.advance();
}
}
// End of the pattern, replace the boundary character with a space
- _ if cursor.curr == boundary => {
+ _ if cursor.curr() == boundary => {
if boundary != b'\n' {
result[cursor.pos] = b' ';
}
@@ -382,4 +387,45 @@ mod tests {
"#;
Ruby::test_extract_contains(input, vec!["z-1", "z-2", "z-3"]);
}
+
+ // https://github.com/tailwindlabs/tailwindcss/issues/19239
+ #[test]
+ fn test_skip_comments() {
+ let input = r#"
+ # From activerecord-8.1.1/lib/active_record/errors.rb:147
+ # Rails uses RDoc cross-reference syntax in inline documentation:
+ # {ActiveRecord::Base#save!}[rdoc-ref:Persistence#save!]
+ "#;
+
+ // Nothing should be extracted from comments, so expect an empty array.
+ Ruby::test_extract_exact(input, vec![]);
+ }
+
+ // https://github.com/tailwindlabs/tailwindcss/issues/19481
+ #[test]
+ fn test_strict_locals() {
+ // Strict locals are defined in a `<%# locals: … %>`, but the `#` looks like a comment
+ // which we should not ignore in this case.
+ let input = r#"
+ <%# locals: (css: "text-amber-600") %>
+ <% more_css = "text-sky-500" %>
+
+
+ In a partial
+
+
+
+ In a partial using explicit local variables
+
+
+
+ In a partial using explicit local variables
+
+ "#;
+
+ Ruby::test_extract_contains(
+ input,
+ vec!["text-amber-600", "text-sky-500", "text-green-500"],
+ );
+ }
}
diff --git a/crates/oxide/src/extractor/pre_processors/rust.rs b/crates/oxide/src/extractor/pre_processors/rust.rs
index 6404fffb5e29..34c9e0c916b7 100644
--- a/crates/oxide/src/extractor/pre_processors/rust.rs
+++ b/crates/oxide/src/extractor/pre_processors/rust.rs
@@ -33,7 +33,7 @@ impl Rust {
let mut bracket_stack = bracket_stack::BracketStack::default();
while cursor.pos < len {
- match cursor.curr {
+ match cursor.curr() {
// Escaped character, skip ahead to the next character
b'\\' => {
cursor.advance_twice();
@@ -46,7 +46,7 @@ impl Rust {
cursor.advance();
while cursor.pos < len {
- match cursor.curr {
+ match cursor.curr() {
// Escaped character, skip ahead to the next character
b'\\' => cursor.advance_twice(),
@@ -89,7 +89,7 @@ impl Rust {
// digit.
// E.g.: `bg-red-500.2xl:flex`
// ^^^
- if cursor.prev.is_ascii_digit() && cursor.next.is_ascii_digit() {
+ if cursor.prev().is_ascii_digit() && cursor.next().is_ascii_digit() {
let mut next_cursor = cursor.clone();
next_cursor.advance();
@@ -103,11 +103,11 @@ impl Rust {
}
b'[' => {
- bracket_stack.push(cursor.curr);
+ bracket_stack.push(cursor.curr());
}
b']' if !bracket_stack.is_empty() => {
- bracket_stack.pop(cursor.curr);
+ bracket_stack.pop(cursor.curr());
}
// Consume everything else
diff --git a/crates/oxide/src/extractor/pre_processors/slim.rs b/crates/oxide/src/extractor/pre_processors/slim.rs
index 6d41e5a09b72..eacfb55eedfd 100644
--- a/crates/oxide/src/extractor/pre_processors/slim.rs
+++ b/crates/oxide/src/extractor/pre_processors/slim.rs
@@ -15,7 +15,7 @@ impl PreProcessor for Slim {
let mut bracket_stack = BracketStack::default();
while cursor.pos < len {
- match cursor.curr {
+ match cursor.curr() {
// Only replace `.` with a space if it's not surrounded by numbers. E.g.:
//
// ```diff
@@ -43,7 +43,7 @@ impl PreProcessor for Slim {
// digit.
// E.g.: `bg-red-500.2xl:flex`
// ^^^
- if cursor.prev.is_ascii_digit() && cursor.next.is_ascii_digit() {
+ if cursor.prev().is_ascii_digit() && cursor.next().is_ascii_digit() {
let mut next_cursor = cursor.clone();
next_cursor.advance();
@@ -65,7 +65,7 @@ impl PreProcessor for Slim {
// class=%w[bg-blue-500 w-10 h-10]
// ]
// ```
- b'%' if matches!(cursor.next, b'w' | b'W')
+ b'%' if matches!(cursor.next(), b'w' | b'W')
&& matches!(cursor.input.get(cursor.pos + 2), Some(b'[' | b'(' | b'{')) =>
{
result[cursor.pos] = b' '; // Replace `%`
@@ -73,7 +73,7 @@ impl PreProcessor for Slim {
result[cursor.pos] = b' '; // Replace `w`
cursor.advance();
result[cursor.pos] = b' '; // Replace `[` or `(` or `{`
- bracket_stack.push(cursor.curr);
+ bracket_stack.push(cursor.curr());
cursor.advance(); // Move past the bracket
continue;
}
@@ -96,10 +96,10 @@ impl PreProcessor for Slim {
// Instead of listing all boundary characters, let's list the characters we know
// will be invalid instead.
b'[' if bracket_stack.is_empty()
- && matches!(cursor.prev, b'a'..=b'z' | b'A'..=b'Z' | b'0'..=b'9') =>
+ && matches!(cursor.prev(), b'a'..=b'z' | b'A'..=b'Z' | b'0'..=b'9') =>
{
result[cursor.pos] = b' ';
- bracket_stack.push(cursor.curr);
+ bracket_stack.push(cursor.curr());
}
// In Slim the class name shorthand can be followed by a parenthesis. E.g.:
@@ -114,17 +114,17 @@ impl PreProcessor for Slim {
//
// However, we also need to make sure that we keep the parens that are part of the
// utility class. E.g.: `bg-(--my-color)`.
- b'(' if bracket_stack.is_empty() && !matches!(cursor.prev, b'-' | b'/') => {
+ b'(' if bracket_stack.is_empty() && !matches!(cursor.prev(), b'-' | b'/') => {
result[cursor.pos] = b' ';
- bracket_stack.push(cursor.curr);
+ bracket_stack.push(cursor.curr());
}
b'(' | b'[' | b'{' => {
- bracket_stack.push(cursor.curr);
+ bracket_stack.push(cursor.curr());
}
b')' | b']' | b'}' if !bracket_stack.is_empty() => {
- bracket_stack.pop(cursor.curr);
+ bracket_stack.pop(cursor.curr());
}
// Consume everything else
diff --git a/crates/oxide/src/extractor/pre_processors/vue.rs b/crates/oxide/src/extractor/pre_processors/vue.rs
index 119e2a3d2079..1b9bf1668cb4 100644
--- a/crates/oxide/src/extractor/pre_processors/vue.rs
+++ b/crates/oxide/src/extractor/pre_processors/vue.rs
@@ -14,13 +14,12 @@ pub struct Vue;
impl PreProcessor for Vue {
fn process(&self, content: &[u8]) -> Vec {
let mut result = content.to_vec();
-
let content_as_str = std::str::from_utf8(content).unwrap();
for (_, [lang, body]) in TEMPLATE_REGEX
.captures_iter(content_as_str)
.map(|c| c.extract())
{
- let replaced = pre_process_input(body.as_bytes(), lang);
+ let replaced = pre_process_input(body.as_bytes().to_vec(), lang);
result = result.replace(body, replaced);
}
diff --git a/crates/oxide/src/extractor/string_machine.rs b/crates/oxide/src/extractor/string_machine.rs
index 9148a1fbf619..4fad49faae19 100644
--- a/crates/oxide/src/extractor/string_machine.rs
+++ b/crates/oxide/src/extractor/string_machine.rs
@@ -30,20 +30,20 @@ impl Machine for StringMachine {
#[inline]
fn next(&mut self, cursor: &mut cursor::Cursor<'_>) -> MachineState {
- if Class::Quote != cursor.curr.into() {
+ if Class::Quote != cursor.curr().into() {
return MachineState::Idle;
}
// Start of a string
let len = cursor.input.len();
let start_pos = cursor.pos;
- let end_char = cursor.curr;
+ let end_char = cursor.curr();
cursor.advance();
while cursor.pos < len {
- match cursor.curr.into() {
- Class::Escape => match cursor.next.into() {
+ match cursor.curr().into() {
+ Class::Escape => match cursor.next().into() {
// An escaped whitespace character is not allowed
Class::Whitespace => return MachineState::Idle,
@@ -52,7 +52,7 @@ impl Machine for StringMachine {
},
// End of the string
- Class::Quote if cursor.curr == end_char => return self.done(start_pos, cursor),
+ Class::Quote if cursor.curr() == end_char => return self.done(start_pos, cursor),
// Any kind of whitespace is not allowed
Class::Whitespace => return MachineState::Idle,
diff --git a/crates/oxide/src/extractor/utility_machine.rs b/crates/oxide/src/extractor/utility_machine.rs
index b9b1038cdb3a..c116ec4e4226 100644
--- a/crates/oxide/src/extractor/utility_machine.rs
+++ b/crates/oxide/src/extractor/utility_machine.rs
@@ -27,12 +27,12 @@ impl Machine for UtilityMachine {
#[inline]
fn next(&mut self, cursor: &mut cursor::Cursor<'_>) -> MachineState {
- match cursor.curr.into() {
+ match cursor.curr().into() {
// LEGACY: Important marker
Class::Exclamation => {
self.legacy_important = true;
- match cursor.next.into() {
+ match cursor.next().into() {
// Start of an arbitrary property
//
// E.g.: `![color:red]`
@@ -78,7 +78,7 @@ impl UtilityMachine {
fn parse_arbitrary_property(&mut self, cursor: &mut cursor::Cursor<'_>) -> MachineState {
match self.arbitrary_property_machine.next(cursor) {
MachineState::Idle => self.restart(),
- MachineState::Done(_) => match cursor.next.into() {
+ MachineState::Done(_) => match cursor.next().into() {
// End of arbitrary property, but there is a potential modifier.
//
// E.g.: `[color:#0088cc]/`
@@ -109,7 +109,7 @@ impl UtilityMachine {
fn parse_named_utility(&mut self, cursor: &mut cursor::Cursor<'_>) -> MachineState {
match self.named_utility_machine.next(cursor) {
MachineState::Idle => self.restart(),
- MachineState::Done(_) => match cursor.next.into() {
+ MachineState::Done(_) => match cursor.next().into() {
// End of a named utility, but there is a potential modifier.
//
// E.g.: `bg-red-500/`
@@ -140,7 +140,7 @@ impl UtilityMachine {
fn parse_modifier(&mut self, cursor: &mut cursor::Cursor<'_>) -> MachineState {
match self.modifier_machine.next(cursor) {
MachineState::Idle => self.restart(),
- MachineState::Done(_) => match cursor.next.into() {
+ MachineState::Done(_) => match cursor.next().into() {
// A modifier followed by a modifier is invalid
Class::Slash => self.restart(),
diff --git a/crates/oxide/src/extractor/variant_machine.rs b/crates/oxide/src/extractor/variant_machine.rs
index 23aa61798643..9ec2adc0922a 100644
--- a/crates/oxide/src/extractor/variant_machine.rs
+++ b/crates/oxide/src/extractor/variant_machine.rs
@@ -16,7 +16,7 @@ impl Machine for VariantMachine {
#[inline]
fn next(&mut self, cursor: &mut cursor::Cursor<'_>) -> MachineState {
- match cursor.curr.into() {
+ match cursor.curr().into() {
// Start of an arbitrary variant
//
// E.g.: `[&:hover]:`
@@ -48,7 +48,7 @@ impl VariantMachine {
start_pos: usize,
cursor: &mut cursor::Cursor<'_>,
) -> MachineState {
- match cursor.next.into() {
+ match cursor.next().into() {
// End of an arbitrary value, must be followed by a `:`
//
// E.g.: `[&:hover]:`
diff --git a/crates/oxide/src/fast_skip.rs b/crates/oxide/src/fast_skip.rs
index 488e61bd68da..54930548c620 100644
--- a/crates/oxide/src/fast_skip.rs
+++ b/crates/oxide/src/fast_skip.rs
@@ -10,7 +10,7 @@ pub fn fast_skip(cursor: &Cursor) -> Option {
return None;
}
- if !cursor.curr.is_ascii_whitespace() {
+ if !cursor.curr().is_ascii_whitespace() {
return None;
}
diff --git a/crates/oxide/src/scanner/detect_sources.rs b/crates/oxide/src/scanner/detect_sources.rs
index 9dc340fbaf47..c519cd00d788 100644
--- a/crates/oxide/src/scanner/detect_sources.rs
+++ b/crates/oxide/src/scanner/detect_sources.rs
@@ -30,11 +30,9 @@ fn sort_by_dir_and_name(a: &DirEntry, z: &DirEntry) -> Ordering {
pub fn resolve_globs(
base: PathBuf,
- dirs: &[PathBuf],
+ dirs: &FxHashSet,
extensions: &FxHashSet,
) -> Vec {
- let allowed_paths: FxHashSet = FxHashSet::from_iter(dirs.iter().cloned());
-
// A list of known extensions + a list of extensions we found in the project.
let mut found_extensions: FxHashSet =
FxHashSet::from_iter(KNOWN_EXTENSIONS.iter().map(|x| x.to_string()));
@@ -72,7 +70,7 @@ pub fn resolve_globs(
continue;
}
- if !allowed_paths.contains(path) {
+ if !dirs.contains(path) {
let mut path = path;
while let Some(parent) = path.parent() {
if parent == base {
@@ -113,7 +111,7 @@ pub fn resolve_globs(
continue;
}
- if !allowed_paths.contains(path) {
+ if !dirs.contains(path) {
continue;
}
diff --git a/crates/oxide/src/scanner/fixtures/ignored-content-dirs.txt b/crates/oxide/src/scanner/fixtures/ignored-content-dirs.txt
index 0921d2ff8c8e..79f01ecc117a 100644
--- a/crates/oxide/src/scanner/fixtures/ignored-content-dirs.txt
+++ b/crates/oxide/src/scanner/fixtures/ignored-content-dirs.txt
@@ -1,14 +1,15 @@
.git
.hg
-.svn
-node_modules
-.yarn
-.venv
-venv
+.jj
.next
-.turbo
.parcel-cache
-__pycache__
-.svelte-kit
.pnpm-store
+.svelte-kit
+.svn
+.turbo
+.venv
.vercel
+.yarn
+__pycache__
+node_modules
+venv
diff --git a/crates/oxide/src/scanner/init_tracing.rs b/crates/oxide/src/scanner/init_tracing.rs
new file mode 100644
index 000000000000..2a570ff20188
--- /dev/null
+++ b/crates/oxide/src/scanner/init_tracing.rs
@@ -0,0 +1,70 @@
+use std::fs::OpenOptions;
+use std::io::{self, Write};
+use std::path::Path;
+use std::sync::{self, Arc, Mutex};
+use tracing_subscriber::fmt::writer::BoxMakeWriter;
+
+pub static SHOULD_TRACE: sync::LazyLock = sync::LazyLock::new(
+ || matches!(std::env::var("DEBUG"), Ok(value) if value.eq("*") || (value.contains("tailwindcss:oxide") && !value.contains("-tailwindcss:oxide"))),
+);
+
+fn dim(input: &str) -> String {
+ format!("\u{001b}[2m{input}\u{001b}[22m")
+}
+
+fn blue(input: &str) -> String {
+ format!("\u{001b}[34m{input}\u{001b}[39m")
+}
+
+fn highlight(input: &str) -> String {
+ format!("{}{}{}", dim(&blue("`")), blue(input), dim(&blue("`")))
+}
+
+struct MutexWriter(Arc>);
+
+impl Write for MutexWriter {
+ fn write(&mut self, buf: &[u8]) -> io::Result {
+ self.0.lock().unwrap().write(buf)
+ }
+
+ fn flush(&mut self) -> io::Result<()> {
+ self.0.lock().unwrap().flush()
+ }
+}
+
+pub fn init_tracing() {
+ if !*SHOULD_TRACE {
+ return;
+ }
+
+ let file_path = format!("tailwindcss-{}.log", std::process::id());
+ let file = OpenOptions::new()
+ .create(true)
+ .append(true)
+ .open(&file_path)
+ .unwrap_or_else(|_| panic!("Failed to open {file_path}"));
+
+ let file_path = Path::new(&file_path);
+ let absolute_file_path = dunce::canonicalize(file_path)
+ .unwrap_or_else(|_| panic!("Failed to canonicalize {file_path:?}"));
+ eprintln!(
+ "{} Writing debug info to: {}\n",
+ dim("[DEBUG]"),
+ highlight(absolute_file_path.as_path().to_str().unwrap())
+ );
+
+ let file = Arc::new(Mutex::new(file));
+
+ let writer: BoxMakeWriter = BoxMakeWriter::new({
+ let file = file.clone();
+ move || Box::new(MutexWriter(file.clone())) as Box
+ });
+
+ _ = tracing_subscriber::fmt()
+ .with_max_level(tracing::Level::INFO)
+ .with_span_events(tracing_subscriber::fmt::format::FmtSpan::ACTIVE)
+ .with_writer(writer)
+ .with_ansi(false)
+ .compact()
+ .try_init();
+}
diff --git a/crates/oxide/src/scanner/mod.rs b/crates/oxide/src/scanner/mod.rs
index ec6aea642481..6d6cabc2aa80 100644
--- a/crates/oxide/src/scanner/mod.rs
+++ b/crates/oxide/src/scanner/mod.rs
@@ -1,5 +1,6 @@
pub mod auto_source_detection;
pub mod detect_sources;
+pub mod init_tracing;
pub mod sources;
use crate::extractor::{Extracted, Extractor};
@@ -14,15 +15,13 @@ use bstr::ByteSlice;
use fast_glob::glob_match;
use fxhash::{FxHashMap, FxHashSet};
use ignore::{gitignore::GitignoreBuilder, WalkBuilder};
+use init_tracing::{init_tracing, SHOULD_TRACE};
use rayon::prelude::*;
use std::collections::{BTreeMap, BTreeSet};
-use std::fs::OpenOptions;
-use std::io::{self, Write};
use std::path::{Path, PathBuf};
-use std::sync::{self, Arc, Mutex};
+use std::sync::{Arc, Mutex};
use std::time::SystemTime;
use tracing::event;
-use tracing_subscriber::fmt::writer::BoxMakeWriter;
// @source "some/folder"; // This is auto source detection
// @source "some/folder/**/*"; // This is auto source detection
@@ -34,70 +33,6 @@ use tracing_subscriber::fmt::writer::BoxMakeWriter;
//
// @source "do-include-me.bin"; // `.bin` is typically ignored, but now it's explicit so should be included
// @source "git-ignored.html"; // A git ignored file that is listed explicitly, should be scanned
-static SHOULD_TRACE: sync::LazyLock = sync::LazyLock::new(
- || matches!(std::env::var("DEBUG"), Ok(value) if value.eq("*") || (value.contains("tailwindcss:oxide") && !value.contains("-tailwindcss:oxide"))),
-);
-
-fn dim(input: &str) -> String {
- format!("\u{001b}[2m{input}\u{001b}[22m")
-}
-
-fn blue(input: &str) -> String {
- format!("\u{001b}[34m{input}\u{001b}[39m")
-}
-
-fn highlight(input: &str) -> String {
- format!("{}{}{}", dim(&blue("`")), blue(input), dim(&blue("`")))
-}
-
-fn init_tracing() {
- if !*SHOULD_TRACE {
- return;
- }
-
- let file_path = format!("tailwindcss-{}.log", std::process::id());
- let file = OpenOptions::new()
- .create(true)
- .append(true)
- .open(&file_path)
- .unwrap_or_else(|_| panic!("Failed to open {file_path}"));
-
- let file_path = Path::new(&file_path);
- let absolute_file_path = dunce::canonicalize(file_path)
- .unwrap_or_else(|_| panic!("Failed to canonicalize {file_path:?}"));
- eprintln!(
- "{} Writing debug info to: {}\n",
- dim("[DEBUG]"),
- highlight(absolute_file_path.as_path().to_str().unwrap())
- );
-
- let file = Arc::new(Mutex::new(file));
-
- let writer: BoxMakeWriter = BoxMakeWriter::new({
- let file = file.clone();
- move || Box::new(MutexWriter(file.clone())) as Box
- });
-
- _ = tracing_subscriber::fmt()
- .with_max_level(tracing::Level::INFO)
- .with_span_events(tracing_subscriber::fmt::format::FmtSpan::ACTIVE)
- .with_writer(writer)
- .with_ansi(false)
- .compact()
- .try_init();
-}
-
-struct MutexWriter(Arc>);
-
-impl Write for MutexWriter {
- fn write(&mut self, buf: &[u8]) -> io::Result {
- self.0.lock().unwrap().write(buf)
- }
-
- fn flush(&mut self) -> io::Result<()> {
- self.0.lock().unwrap().flush()
- }
-}
#[derive(Debug, Clone)]
pub enum ChangedContent {
@@ -129,26 +64,32 @@ pub struct Scanner {
/// The walker to detect all files that we have to scan
walker: Option,
- /// All changed content that we have to parse
- changed_content: Vec,
-
/// All found extensions
extensions: FxHashSet,
- /// All CSS files we want to scan for CSS variable usage
- css_files: Vec,
-
/// All files that we have to scan
- files: Vec,
+ files: FxHashSet,
/// All directories, sub-directories, etc… we saw during source detection
- dirs: Vec,
+ dirs: FxHashSet,
/// All generated globs, used for setting up watchers
globs: Option>,
/// Track unique set of candidates
candidates: FxHashSet,
+
+ /// Track mtimes for files so re-scans can skip unchanged files.
+ /// Only populated after the first scan completes (to avoid unnecessary
+ /// metadata calls on initial build).
+ mtimes: FxHashMap,
+
+ /// Whether we've completed at least one full scan. When false, we skip
+ /// mtime tracking entirely so the initial build stays fast.
+ has_scanned_once: bool,
+
+ /// Whether sources have been scanned since the last `scan()` call
+ sources_scanned: bool,
}
impl Scanner {
@@ -163,7 +104,6 @@ impl Scanner {
}
let sources = Sources::new(public_source_entries_to_private_source_entries(sources));
-
if *SHOULD_TRACE {
event!(tracing::Level::INFO, "Optimized sources:");
for source in sources.iter() {
@@ -171,29 +111,26 @@ impl Scanner {
}
}
+ let walker = create_walker(&sources);
+
Self {
- sources: sources.clone(),
- walker: create_walker(sources),
+ sources,
+ walker,
..Default::default()
}
}
pub fn scan(&mut self) -> Vec {
- self.scan_sources();
+ self.sources_scanned = false;
- // TODO: performance improvement, bail early if we don't have any changed content
- // if self.changed_content.is_empty() {
- // return vec![];
- // }
+ let (scanned_blobs, css_files) = self.discover_sources();
- let _new_candidates = self.extract_candidates();
+ self.extract_candidates(scanned_blobs, css_files);
- // Make sure we have a sorted list of candidates
- let mut candidates = self.candidates.iter().cloned().collect::<_>>();
- candidates.par_sort_unstable();
-
- // Return all candidates instead of only the new ones
- candidates
+ // Return all candidates sorted
+ let mut result = self.candidates.iter().cloned().collect::<_>>();
+ result.par_sort_unstable();
+ result
}
#[tracing::instrument(skip_all)]
@@ -208,7 +145,7 @@ impl Scanner {
// Raw content can be parsed directly, no need to verify if the file exists and is allowed
// to be scanned.
- self.changed_content.extend(changed_contents);
+ let mut content_to_scan: Vec = changed_contents;
// Fully resolve all files
let changed_files = changed_files
@@ -232,7 +169,7 @@ impl Scanner {
});
// All known files are allowed to be scanned
- self.changed_content.extend(known_files);
+ content_to_scan.extend(known_files);
// Figure out if the new unknown files are allowed to be scanned
if !new_unknown_files.is_empty() {
@@ -252,8 +189,8 @@ impl Scanner {
// When the file is found on disk it means that all the rules pass. We can
// extract the current file and remove it from the list of passed in files.
if file == path {
- self.files.push(path.to_path_buf()); // Track for future use
- self.changed_content.push(changed_file.clone()); // Track for parsing
+ self.files.insert(path.to_path_buf()); // Track for future use
+ content_to_scan.push(changed_file.clone()); // Track for parsing
drop_file_indexes.push(idx);
}
}
@@ -274,18 +211,17 @@ impl Scanner {
}
}
- self.extract_candidates()
+ // Read all content into blobs for extraction
+ let blobs = read_all_files(content_to_scan);
+ self.extract_candidates(blobs, vec![])
}
#[tracing::instrument(skip_all)]
- fn extract_candidates(&mut self) -> Vec {
- let changed_content = self.changed_content.drain(..).collect::<_>>();
-
- // Extract all candidates from the changed content
- let mut new_candidates = parse_all_blobs(read_all_files(changed_content));
+ fn extract_candidates(&mut self, blobs: Vec>, css_files: Vec) -> Vec {
+ // Extract all candidates from the pre-read blobs
+ let mut new_candidates = parse_all_blobs(blobs);
// Extract all CSS variables from the CSS files
- let css_files = self.css_files.drain(..).collect::<_>>();
if !css_files.is_empty() {
let css_variables = extract_css_variables(read_all_files(
css_files
@@ -297,63 +233,23 @@ impl Scanner {
new_candidates.extend(css_variables);
}
- // Only compute the new candidates and ignore the ones we already have. This is for
- // subsequent calls to prevent serializing the entire set of candidates every time.
- let mut new_candidates = new_candidates
- .into_par_iter()
- .filter(|candidate| !self.candidates.contains(candidate))
- .collect::<_>>();
-
- new_candidates.par_sort_unstable();
+ // Only keep candidates we haven't seen before
+ for existing in self.candidates.iter() {
+ new_candidates.remove(existing);
+ }
// Track new candidates for subsequent calls
- self.candidates.par_extend(new_candidates.clone());
-
- new_candidates
- }
-
- #[tracing::instrument(skip_all)]
- fn scan_sources(&mut self) {
- let Some(walker) = &mut self.walker else {
- return;
- };
+ self.candidates.extend(new_candidates.iter().cloned());
- for entry in walker.build().filter_map(Result::ok) {
- let path = entry.into_path();
- let Ok(metadata) = path.metadata() else {
- continue;
- };
- if metadata.is_dir() {
- self.dirs.push(path);
- } else if metadata.is_file() {
- let extension = path
- .extension()
- .and_then(|x| x.to_str())
- .unwrap_or_default(); // In case the file has no extension
+ let mut result: Vec = new_candidates.into_iter().collect();
+ result.par_sort_unstable();
- match extension {
- // Special handing for CSS files, we don't want to extract candidates from
- // these files, but we do want to extract used CSS variables.
- "css" => {
- self.css_files.push(path.clone());
- }
- _ => {
- self.changed_content.push(ChangedContent::File(
- path.to_path_buf(),
- extension.to_owned(),
- ));
- }
- }
-
- self.extensions.insert(extension.to_owned());
- self.files.push(path);
- }
- }
+ result
}
#[tracing::instrument(skip_all)]
pub fn get_files(&mut self) -> Vec {
- self.scan_sources();
+ let _ = self.discover_sources();
self.files
.par_iter()
@@ -367,7 +263,7 @@ impl Scanner {
return globs.clone();
}
- self.scan_sources();
+ let _ = self.discover_sources();
let mut globs = vec![];
for source in self.sources.iter() {
@@ -456,6 +352,99 @@ impl Scanner {
})
.collect()
}
+
+ #[tracing::instrument(skip_all)]
+ fn discover_sources(&mut self) -> (Vec>, Vec) {
+ if self.sources_scanned {
+ return (vec![], vec![]);
+ }
+ self.sources_scanned = true;
+
+ let Some(walker) = &mut self.walker else {
+ return (vec![], vec![]);
+ };
+
+ // Use synchronous walk for the initial build (lower overhead) and parallel
+ // walk for subsequent calls (watch mode) where the overhead is amortised.
+ let all_entries = if self.has_scanned_once {
+ walk_parallel(walker)
+ } else {
+ walk_synchronous(walker)
+ };
+
+ let mut css_files: Vec = vec![];
+ let mut content_paths: Vec<(PathBuf, String)> = Vec::new();
+ let mut seen_files: FxHashSet = FxHashSet::default();
+
+ for (path, is_dir, extension) in all_entries {
+ if is_dir {
+ self.dirs.insert(path);
+ } else {
+ // Deduplicate: parallel walk can visit the same file from multiple threads
+ if !seen_files.insert(path.clone()) {
+ continue;
+ }
+
+ // On re-scans, check mtime to skip unchanged files.
+ // On the first scan we skip this entirely to avoid extra
+ // metadata syscalls.
+ let changed = if self.has_scanned_once {
+ let current_mtime = std::fs::metadata(&path)
+ .ok()
+ .and_then(|m| m.modified().ok());
+
+ match current_mtime {
+ Some(mtime) => {
+ let prev = self.mtimes.insert(path.clone(), mtime);
+ prev.is_none_or(|prev| prev != mtime)
+ }
+ None => true,
+ }
+ } else {
+ true
+ };
+
+ match extension.as_str() {
+ // Special handing for CSS files, we don't want to extract candidates from
+ // these files, but we do want to extract used CSS variables.
+ "css" => {
+ if changed {
+ css_files.push(path.clone());
+ }
+ }
+ _ => {
+ if changed {
+ content_paths.push((path.clone(), extension.clone()));
+ }
+ }
+ }
+
+ self.extensions.insert(extension);
+ self.files.insert(path);
+ }
+ }
+
+ // Read + preprocess all discovered files in parallel
+ let scanned_blobs: Vec> = content_paths
+ .into_par_iter()
+ .filter_map(|(path, ext)| {
+ let content = std::fs::read(&path).ok()?;
+ event!(tracing::Level::INFO, "Reading {:?}", path);
+ let processed = pre_process_input(content, &ext);
+ if processed.is_empty() {
+ None
+ } else {
+ Some(processed)
+ }
+ })
+ .collect();
+
+ if !self.has_scanned_once {
+ self.has_scanned_once = true;
+ }
+
+ (scanned_blobs, css_files)
+ }
}
fn read_changed_content(c: ChangedContent) -> Option> {
@@ -474,26 +463,26 @@ fn read_changed_content(c: ChangedContent) -> Option> {
ChangedContent::Content(contents, extension) => (contents.into_bytes(), extension),
};
- Some(pre_process_input(&content, &extension))
+ Some(pre_process_input(content, &extension))
}
-pub fn pre_process_input(content: &[u8], extension: &str) -> Vec {
+pub fn pre_process_input(content: Vec, extension: &str) -> Vec {
use crate::extractor::pre_processors::*;
match extension {
- "clj" | "cljs" | "cljc" => Clojure.process(content),
- "heex" | "eex" | "ex" | "exs" => Elixir.process(content),
- "cshtml" | "razor" => Razor.process(content),
- "haml" => Haml.process(content),
- "json" => Json.process(content),
- "md" | "mdx" => Markdown.process(content),
- "pug" => Pug.process(content),
- "rb" | "erb" => Ruby.process(content),
- "slim" | "slang" => Slim.process(content),
- "svelte" => Svelte.process(content),
- "rs" => Rust.process(content),
- "vue" => Vue.process(content),
- _ => content.to_vec(),
+ "clj" | "cljs" | "cljc" => Clojure.process(&content),
+ "heex" | "eex" | "ex" | "exs" => Elixir.process(&content),
+ "cshtml" | "razor" => Razor.process(&content),
+ "haml" => Haml.process(&content),
+ "json" => Json.process(&content),
+ "md" | "mdx" => Markdown.process(&content),
+ "pug" => Pug.process(&content),
+ "rb" | "erb" => Ruby.process(&content),
+ "slim" | "slang" => Slim.process(&content),
+ "svelte" => Svelte.process(&content),
+ "rs" => Rust.process(&content),
+ "vue" => Vue.process(&content),
+ _ => content,
}
}
@@ -512,23 +501,23 @@ fn read_all_files(changed_content: Vec) -> Vec> {
}
#[tracing::instrument(skip_all)]
-fn extract_css_variables(blobs: Vec>) -> Vec {
+fn extract_css_variables(blobs: Vec>) -> FxHashSet {
extract(blobs, |mut extractor| {
extractor.extract_variables_from_css()
})
}
#[tracing::instrument(skip_all)]
-fn parse_all_blobs(blobs: Vec>) -> Vec {
+fn parse_all_blobs(blobs: Vec>) -> FxHashSet {
extract(blobs, |mut extractor| extractor.extract())
}
#[tracing::instrument(skip_all)]
-fn extract(blobs: Vec>, handle: H) -> Vec
+fn extract(blobs: Vec>, handle: H) -> FxHashSet
where
H: Fn(Extractor) -> Vec + std::marker::Sync,
{
- let mut result: Vec<_> = blobs
+ blobs
.par_iter()
.flat_map(|blob| blob.par_split(|x| *x == b'\n'))
.filter_map(|blob| {
@@ -554,22 +543,97 @@ where
})
.into_iter()
.map(|s| unsafe { String::from_utf8_unchecked(s.to_vec()) })
- .collect();
+ .collect()
+}
+
+type WalkEntry = (PathBuf, bool, String);
- // SAFETY: Unstable sort is faster and in this scenario it's also safe because we are
- // guaranteed to have unique candidates.
- result.par_sort_unstable();
+/// Walk the file system synchronously. Used for the initial build where the overhead of spawning
+/// parallel walker threads is not worth it.
+#[tracing::instrument(skip_all)]
+fn walk_synchronous(walker: &mut WalkBuilder) -> Vec {
+ let mut entries = Vec::new();
+
+ for entry in walker.build().filter_map(Result::ok) {
+ let is_dir = entry.file_type().map(|ft| ft.is_dir()).unwrap_or(false);
+ let path = entry.into_path();
+
+ if is_dir {
+ entries.push((path, true, String::new()));
+ } else {
+ let ext = path
+ .extension()
+ .and_then(|x| x.to_str())
+ .unwrap_or_default()
+ .to_owned();
+ entries.push((path, false, ext));
+ }
+ }
- result
+ entries
}
-/// Create a walker for the given sources to detect all the files that we have to scan.
+/// Walk the file system in parallel. Used in watch mode where the parallel walker overhead is
+/// amortised across many rebuilds and subsequent calls are much faster.
+#[tracing::instrument(skip_all)]
+fn walk_parallel(walker: &mut WalkBuilder) -> Vec {
+ struct FlushOnDrop {
+ local: Vec,
+ shared: Arc>>,
+ }
+
+ impl Drop for FlushOnDrop {
+ fn drop(&mut self) {
+ if !self.local.is_empty() {
+ self.shared.lock().unwrap().append(&mut self.local);
+ }
+ }
+ }
+
+ let collected: Arc>> = Arc::new(Mutex::new(Vec::new()));
+
+ walker.build_parallel().run(|| {
+ let mut buf = FlushOnDrop {
+ local: Vec::with_capacity(256),
+ shared: collected.clone(),
+ };
+
+ Box::new(move |entry| {
+ let Ok(entry) = entry else {
+ return ignore::WalkState::Continue;
+ };
+
+ let is_dir = entry.file_type().map(|ft| ft.is_dir()).unwrap_or(false);
+ let path = entry.into_path();
+
+ if is_dir {
+ buf.local.push((path, true, String::new()));
+ } else {
+ let ext = path
+ .extension()
+ .and_then(|x| x.to_str())
+ .unwrap_or_default()
+ .to_owned();
+ buf.local.push((path, false, ext));
+ }
+
+ if buf.local.len() >= 256 {
+ buf.shared.lock().unwrap().append(&mut buf.local);
+ }
+
+ ignore::WalkState::Continue
+ })
+ });
+
+ // All threads have finished and flushed their buffers via FlushOnDrop::drop
+ Arc::try_unwrap(collected).unwrap().into_inner().unwrap()
+}
+
+/// Sets up a WalkBuilder with all source roots, gitignore rules, and source pattern matching.
///
-/// The `mtimes` map is used to keep track of the last modified time of each file. This is used to
-/// determine if a file or folder has changed since the last scan and we can skip folders that
-/// haven't changed.
-fn create_walker(sources: Sources) -> Option {
- let mtimes: Arc>> = Default::default();
+/// This is the common setup shared between the full walker (with mtime tracking for re-scans)
+/// and the parallel walker (without mtime tracking for the initial scan).
+fn create_walker(sources: &Sources) -> Option {
let mut other_roots: FxHashSet<&PathBuf> = FxHashSet::default();
let mut first_root: Option<&PathBuf> = None;
let mut ignores: BTreeMap<&PathBuf, BTreeSet> = Default::default();
@@ -717,75 +781,68 @@ fn create_walker(sources: Sources) -> Option {
builder.add_gitignore(ignore);
}
- builder.filter_entry({
- move |entry| {
- let path = entry.path();
-
- // Ensure the entries are matching any of the provided source patterns (this is
- // necessary for manual-patterns that can filter the file extension)
- if path.is_file() {
- let mut matches = false;
- for source in sources.iter() {
- match source {
- SourceEntry::Auto { base } | SourceEntry::External { base } => {
- if path.starts_with(base) {
- matches = true;
- break;
- }
- }
- SourceEntry::Pattern { base, pattern } => {
- let mut pattern = pattern.to_string();
- // Ensure that the pattern is pinned to the base path.
- if !pattern.starts_with("/") {
- pattern = format!("/{pattern}");
- }
-
- // Check if path starts with base, if so, remove the prefix and check the remainder against the pattern
- let remainder = path.strip_prefix(base);
- if remainder.is_ok_and(|remainder| {
- let mut path_str = remainder.to_string_lossy().to_string();
- if !path_str.starts_with("/") {
- path_str = format!("/{path_str}");
- }
- glob_match(pattern, path_str.as_bytes())
- }) {
- matches = true;
- break;
- }
- }
- _ => {}
- }
- }
+ // Pre-compute source matching data to avoid allocations in the hot filter_entry path
+ let auto_bases: Vec = sources
+ .iter()
+ .filter_map(|source| match source {
+ SourceEntry::Auto { base } | SourceEntry::External { base } => Some(base.clone()),
+ _ => None,
+ })
+ .collect();
- if !matches {
- return false;
- }
+ let pattern_sources: Vec<(PathBuf, String)> = sources
+ .iter()
+ .filter_map(|source| match source {
+ SourceEntry::Pattern { base, pattern } => {
+ let normalized = if pattern.starts_with("/") {
+ pattern.to_string()
+ } else {
+ format!("/{pattern}")
+ };
+ Some((base.clone(), normalized))
}
+ _ => None,
+ })
+ .collect();
- let mut mtimes = mtimes.lock().unwrap();
- let current_time = match entry.metadata() {
- Ok(metadata) if metadata.is_file() => {
- if let Ok(time) = metadata.modified() {
- Some(time)
- } else {
- None
- }
- }
- _ => None,
- };
+ // Source pattern matching filter (lock-free, safe for parallel walking)
+ builder.filter_entry(move |entry| {
+ let path = entry.path();
- let previous_time =
- current_time.and_then(|time| mtimes.insert(entry.clone().into_path(), time));
+ // Ensure the entries are matching any of the provided source patterns (this is
+ // necessary for manual-patterns that can filter the file extension)
+ if path.is_file() {
+ let mut matches = false;
- match (current_time, previous_time) {
- (Some(current), Some(prev)) if prev == current => false,
- _ => {
- event!(tracing::Level::INFO, "Discovering {:?}", path);
+ for base in &auto_bases {
+ if path.starts_with(base) {
+ matches = true;
+ break;
+ }
+ }
- true
+ if !matches {
+ for (base, pattern) in &pattern_sources {
+ let remainder = path.strip_prefix(base);
+ if remainder.is_ok_and(|remainder| {
+ let mut path_str = remainder.to_string_lossy().to_string();
+ if !path_str.starts_with("/") {
+ path_str = format!("/{path_str}");
+ }
+ glob_match(pattern, path_str.as_bytes())
+ }) {
+ matches = true;
+ break;
+ }
}
}
+
+ if !matches {
+ return false;
+ }
}
+
+ true
});
Some(builder)
diff --git a/integrations/cli/index.test.ts b/integrations/cli/index.test.ts
index 870a1baec3a9..409a9de7cd41 100644
--- a/integrations/cli/index.test.ts
+++ b/integrations/cli/index.test.ts
@@ -752,7 +752,7 @@ describe.each([
expect(map.at(4, 0)).toMatchObject({
source: null,
original: '(none)',
- generated: '}...',
+ generated: '}\n\n/*# sou...',
})
},
)
@@ -815,7 +815,7 @@ describe.each([
expect(map.at(4, 0)).toMatchObject({
source: null,
original: '(none)',
- generated: '}...',
+ generated: '}\n\n/*# sou...',
})
},
)
@@ -1118,7 +1118,7 @@ describe.each([
expect(map.at(4, 0)).toMatchObject({
source: null,
original: '(none)',
- generated: '}...',
+ generated: '}\n\n/*# sou...',
})
// Write to project source files
@@ -1190,7 +1190,7 @@ describe.each([
expect(map.at(7, 0)).toMatchObject({
source: null,
original: '(none)',
- generated: '}...',
+ generated: '}\n\n/*# sou...',
})
// Write to the main CSS file
@@ -1290,7 +1290,7 @@ describe.each([
expect(map.at(10, 0)).toMatchObject({
source: null,
original: '(none)',
- generated: '}...',
+ generated: '}\n\n/*# sou...',
})
},
)
diff --git a/integrations/cli/plugins.test.ts b/integrations/cli/plugins.test.ts
index 0597e247be50..c0f7c39c3a41 100644
--- a/integrations/cli/plugins.test.ts
+++ b/integrations/cli/plugins.test.ts
@@ -117,7 +117,7 @@ test(
await fs.expectFileToContain('dist/out.css', [
//
`::-webkit-date-and-time-value`,
- `[type='checkbox']:indeterminate`,
+ `input:where([type='checkbox']):indeterminate`,
])
// No classes are included even though they are used in the HTML
diff --git a/integrations/oxide/wasm.test.ts b/integrations/oxide/wasm.test.ts
index 1cbdfce6e1fb..ac2231672386 100644
--- a/integrations/oxide/wasm.test.ts
+++ b/integrations/oxide/wasm.test.ts
@@ -1,6 +1,6 @@
import { css, js, json, test } from '../utils'
-// This test runs the wasm build using the `node:wasi` runtine.
+// This test runs the wasm build using the `node:wasi` runtime.
//
// There are currently a known problems that the Node WASI preview implementation does not properly
// handle FS reads on macOS and it does not implement all APIs on Windows. Because of that, this
diff --git a/integrations/package.json b/integrations/package.json
index c6e792fc447f..8c0d83543a30 100644
--- a/integrations/package.json
+++ b/integrations/package.json
@@ -3,7 +3,7 @@
"version": "0.0.0",
"private": true,
"devDependencies": {
- "dedent": "1.7.0",
+ "dedent": "1.7.1",
"fast-glob": "^3.3.3",
"source-map-js": "^1.2.1"
}
diff --git a/integrations/postcss/core-as-postcss-plugin.test.ts b/integrations/postcss/core-as-postcss-plugin.test.ts
index 17545fea32d8..0856210fec98 100644
--- a/integrations/postcss/core-as-postcss-plugin.test.ts
+++ b/integrations/postcss/core-as-postcss-plugin.test.ts
@@ -48,7 +48,7 @@ describe.each(Object.keys(variantConfig))('%s', (variant) => {
},
},
async ({ exec, expect }) => {
- expect(
+ await expect(
exec('pnpm postcss src/index.css --output dist/out.css', undefined, { ignoreStdErr: true }),
).rejects.toThrowError(
`It looks like you're trying to use \`tailwindcss\` directly as a PostCSS plugin. The PostCSS plugin has moved to a separate package, so to continue using Tailwind CSS with PostCSS you'll need to install \`@tailwindcss/postcss\` and update your PostCSS configuration.`,
diff --git a/integrations/postcss/index.test.ts b/integrations/postcss/index.test.ts
index 08ea852f950c..80025f945411 100644
--- a/integrations/postcss/index.test.ts
+++ b/integrations/postcss/index.test.ts
@@ -698,9 +698,7 @@ test(
`)
- await process.onStderr((message) =>
- message.includes('does-not-exist is not exported from package'),
- )
+ await process.onStderr((message) => message.includes('"./does-not-exist" is not exported'))
expect(await fs.dumpFiles('dist/*.css')).toMatchInlineSnapshot(`
"
@@ -743,9 +741,7 @@ test(
`,
)
- await process.onStderr((message) =>
- message.includes('does-not-exist is not exported from package'),
- )
+ await process.onStderr((message) => message.includes('"./does-not-exist" is not exported'))
expect(await fs.dumpFiles('dist/*.css')).toMatchInlineSnapshot(`
"
diff --git a/integrations/postcss/next.test.ts b/integrations/postcss/next.test.ts
index 969254a75c8c..7fc0ccdcf14e 100644
--- a/integrations/postcss/next.test.ts
+++ b/integrations/postcss/next.test.ts
@@ -468,7 +468,7 @@ test(
// the CSS
await fetchStyles(url)
- // At this point, no changes should triger a compile step. If we see any
+ // At this point, no changes should trigger a compile step. If we see any
// changes, there is an infinite loop because we (the user) didn't write any
// files to disk.
//
diff --git a/integrations/upgrade/index.test.ts b/integrations/upgrade/index.test.ts
index 029ed77a89b3..46b657694ca3 100644
--- a/integrations/upgrade/index.test.ts
+++ b/integrations/upgrade/index.test.ts
@@ -175,7 +175,7 @@ test(
`upgrades a v3 project with prefixes to v4`,
{
// Somehow this test takes *way* longer than the rest (but not always?)
- timeout: 120_000,
+ timeout: 180_000,
fs: {
'package.json': json`
{
@@ -603,6 +603,7 @@ test(
test(
'migrates a simple postcss setup',
{
+ timeout: 120_000,
fs: {
'package.json': json`
{
@@ -774,6 +775,7 @@ test(
test(
'migrates a postcss setup using package.json config',
{
+ timeout: 120_000,
fs: {
'package.json': json`
{
@@ -847,6 +849,7 @@ test(
test(
'migrates a postcss setup using a json based config file',
{
+ timeout: 120_000,
fs: {
'package.json': json`
{
diff --git a/integrations/utils.ts b/integrations/utils.ts
index a2fc0d58af9a..c5d3306c4677 100644
--- a/integrations/utils.ts
+++ b/integrations/utils.ts
@@ -498,6 +498,7 @@ async function overwriteVersionsInPackageJson(content: string): Promise
json.pnpm.overrides['@tailwindcss/cli>tailwindcss'] = resolveVersion(pkg)
json.pnpm.overrides['@tailwindcss/postcss>tailwindcss'] = resolveVersion(pkg)
json.pnpm.overrides['@tailwindcss/vite>tailwindcss'] = resolveVersion(pkg)
+ json.pnpm.overrides['@tailwindcss/webpack>tailwindcss'] = resolveVersion(pkg)
} else {
json.pnpm.overrides[pkg] = resolveVersion(pkg)
}
diff --git a/integrations/vite/astro.test.ts b/integrations/vite/astro.test.ts
index 43406624c316..f828b5071b60 100644
--- a/integrations/vite/astro.test.ts
+++ b/integrations/vite/astro.test.ts
@@ -1,4 +1,4 @@
-import { candidate, fetchStyles, html, js, json, retryAssertion, test, ts } from '../utils'
+import { candidate, css, fetchStyles, html, js, json, retryAssertion, test, ts } from '../utils'
test(
'dev mode',
@@ -129,3 +129,73 @@ test(
await fs.expectFileToContain(files[0][0], [candidate`underline`, candidate`overline`])
},
)
+
+// https://github.com/tailwindlabs/tailwindcss/issues/19677
+test(
+ 'import aliases should work in
+
+
+ Astro
+
+ 
- 
- 
+