1use crate::context::{DeclarationContext, PropertyHandlerContext};
7use crate::css_modules::{hash, CssModule, CssModuleExports, CssModuleReferences};
8use crate::declaration::{DeclarationBlock, DeclarationHandler};
9use crate::dependencies::Dependency;
10use crate::error::{Error, ErrorLocation, MinifyErrorKind, ParserError, PrinterError, PrinterErrorKind};
11use crate::parser::{DefaultAtRule, DefaultAtRuleParser, TopLevelRuleParser};
12#[cfg(feature = "custom_sourcemap")]
13use crate::printer::SourceMap;
14use crate::printer::{Printer, PrinterTrait};
15use crate::rules::{CssRule, CssRuleList, MinifyContext};
16use crate::targets::{should_compile, Targets, TargetsWithSupportsScope};
17use crate::traits::{AtRuleParser, ToCss};
18use crate::values::string::CowArcStr;
19#[cfg(feature = "visitor")]
20use crate::visitor::{Visit, VisitTypes, Visitor};
21use cssparser::{Parser, ParserInput, StyleSheetParser};
22use std::collections::{HashMap, HashSet};
23
24pub use crate::parser::{ParserFlags, ParserOptions};
25pub use crate::printer::PrinterOptions;
26pub use crate::printer::PseudoClasses;
27
28#[derive(Debug, Clone)]
62#[cfg_attr(
63 feature = "serde",
64 derive(serde::Serialize, serde::Deserialize),
65 serde(rename_all = "camelCase")
66)]
67#[cfg_attr(
68 feature = "jsonschema",
69 derive(schemars::JsonSchema),
70 schemars(rename = "StyleSheet", bound = "T: schemars::JsonSchema")
71)]
72#[cfg_attr(feature = "into_owned", derive(rspack_lightningcss_static_self::IntoOwned))]
73pub struct StyleSheet<'i, T = DefaultAtRule> {
74 #[cfg_attr(feature = "serde", serde(borrow))]
76 pub rules: CssRuleList<'i, T>,
77 pub sources: Vec<String>,
80 pub source_map_urls: Vec<Option<String>>,
82 #[cfg(feature = "custom_sourcemap")]
84 #[cfg_attr(feature = "serde", serde(skip))]
85 pub(crate) source_map_source_indices: Vec<Option<u32>>,
86 pub license_comments: Vec<CowArcStr<'i>>,
88 #[cfg_attr(feature = "serde", serde(skip))]
91 pub(crate) content_hashes: Option<Vec<String>>,
92 #[cfg_attr(feature = "serde", serde(skip))]
93 options: ParserOptions<'i>,
95}
96
97#[derive(Default)]
100pub struct MinifyOptions {
101 pub targets: Targets,
103 pub unused_symbols: HashSet<String>,
106}
107
108#[derive(Debug)]
111pub struct ToCssResult {
112 pub code: String,
114 pub exports: Option<CssModuleExports>,
117 pub references: Option<CssModuleReferences>,
120 pub dependencies: Option<Vec<Dependency>>,
123}
124
125impl<'i, 'o> StyleSheet<'i, DefaultAtRule> {
126 pub fn parse(code: &'i str, options: ParserOptions<'i>) -> Result<Self, Error<ParserError<'i>>> {
128 Self::parse_with(code, options, &mut DefaultAtRuleParser)
129 }
130}
131
132impl<'i, T> StyleSheet<'i, T>
133where
134 T: ToCss + Clone,
135{
136 pub fn new(sources: Vec<String>, rules: CssRuleList<'i, T>, options: ParserOptions<'i>) -> StyleSheet<'i, T> {
138 StyleSheet {
139 sources,
140 source_map_urls: Vec::new(),
141 #[cfg(feature = "custom_sourcemap")]
142 source_map_source_indices: Vec::new(),
143 license_comments: Vec::new(),
144 content_hashes: None,
145 rules,
146 options,
147 }
148 }
149
150 pub fn parse_with<P: AtRuleParser<'i, AtRule = T>>(
152 code: &'i str,
153 mut options: ParserOptions<'i>,
154 at_rule_parser: &mut P,
155 ) -> Result<Self, Error<ParserError<'i>>> {
156 let mut input = ParserInput::new(&code);
157 let mut parser = Parser::new(&mut input);
158 let mut license_comments = Vec::new();
159
160 let mut content_hashes = None;
161 if let Some(config) = &options.css_modules {
162 if config.pattern.has_content_hash() {
163 content_hashes = Some(vec![hash(
164 &code,
165 matches!(config.pattern.segments[0], crate::css_modules::Segment::ContentHash),
166 )]);
167 }
168 }
169
170 let mut state = parser.state();
171 while let Ok(token) = parser.next_including_whitespace_and_comments() {
172 match token {
173 cssparser::Token::WhiteSpace(..) => {}
174 cssparser::Token::Comment(comment) if comment.starts_with('!') => {
175 license_comments.push((*comment).into());
176 }
177 cssparser::Token::Comment(comment) if comment.contains("cssmodules-pure-no-check") => {
178 if let Some(css_modules) = &mut options.css_modules {
179 css_modules.pure = false;
180 }
181 }
182 _ => break,
183 }
184 state = parser.state();
185 }
186 parser.reset(&state);
187
188 let mut rules = CssRuleList(vec![]);
189 let mut rule_parser = TopLevelRuleParser::new(&mut options, at_rule_parser, &mut rules);
190 let mut rule_list_parser = StyleSheetParser::new(&mut parser, &mut rule_parser);
191
192 while let Some(rule) = rule_list_parser.next() {
193 match rule {
194 Ok(()) => {}
195 Err((e, _)) => {
196 let options = &mut rule_list_parser.parser.options;
197 if options.error_recovery {
198 options.warn(e);
199 continue;
200 }
201
202 return Err(Error::from(e, options.filename.clone()));
203 }
204 }
205 }
206
207 Ok(StyleSheet {
208 sources: vec![options.filename.clone()],
209 source_map_urls: vec![parser.current_source_map_url().map(|s| s.to_owned())],
210 #[cfg(feature = "custom_sourcemap")]
211 source_map_source_indices: Vec::new(),
212 content_hashes,
213 rules,
214 license_comments,
215 options,
216 })
217 }
218
219 pub fn source_map_url(&self, source_index: usize) -> Option<&String> {
221 self.source_map_urls.get(source_index)?.as_ref()
222 }
223
224 #[cfg(feature = "custom_sourcemap")]
226 pub fn source_map<S: SourceMap>(&self, source_index: usize) -> Option<S> {
227 S::from_data_url("/", self.source_map_url(source_index)?)
228 }
229
230 pub fn minify(&mut self, options: MinifyOptions) -> Result<(), Error<MinifyErrorKind>> {
232 let context = PropertyHandlerContext::new(options.targets, &options.unused_symbols);
233 let mut handler = DeclarationHandler::default();
234 let mut important_handler = DeclarationHandler::default();
235
236 let custom_media = if self.options.flags.contains(ParserFlags::CUSTOM_MEDIA)
239 && should_compile!(options.targets, CustomMediaQueries)
240 {
241 let mut custom_media = HashMap::new();
242 for rule in &self.rules.0 {
243 if let CssRule::CustomMedia(rule) = rule {
244 custom_media.insert(rule.name.0.clone(), rule.clone());
245 }
246 }
247 Some(custom_media)
248 } else {
249 None
250 };
251
252 let mut ctx = MinifyContext {
253 targets: TargetsWithSupportsScope::new(options.targets),
254 handler: &mut handler,
255 important_handler: &mut important_handler,
256 handler_context: context,
257 unused_symbols: &options.unused_symbols,
258 custom_media,
259 css_modules: self.options.css_modules.is_some(),
260 pure_css_modules: self.options.css_modules.as_ref().map(|c| c.pure).unwrap_or_default(),
261 };
262
263 self.rules.minify(&mut ctx, false).map_err(|e| Error {
264 kind: e.kind,
265 loc: Some(ErrorLocation::new(
266 e.loc,
267 self.sources[e.loc.source_index as usize].clone(),
268 )),
269 })?;
270
271 Ok(())
272 }
273
274 #[cfg(feature = "custom_sourcemap")]
276 pub fn to_css<'a, S: SourceMap>(
277 &self,
278 options: PrinterOptions<'a>,
279 source_map: Option<&'a mut S>,
280 ) -> Result<ToCssResult, Error<PrinterErrorKind>> {
281 self.to_css_impl(options, source_map)
282 }
283
284 #[cfg(not(feature = "custom_sourcemap"))]
286 pub fn to_css<'a>(&self, options: PrinterOptions<'a>) -> Result<ToCssResult, Error<PrinterErrorKind>> {
287 self.to_css_impl(options)
288 }
289
290 fn to_css_impl<'a, #[cfg(feature = "custom_sourcemap")] S: SourceMap>(
291 &self,
292 options: PrinterOptions<'a>,
293 #[cfg(feature = "custom_sourcemap")] source_map: Option<&'a mut S>,
294 ) -> Result<ToCssResult, Error<PrinterErrorKind>> {
295 let mut dest = String::with_capacity(1);
297 let project_root = options.project_root.clone();
298 let printer = Printer::new(&mut dest, options);
299 #[cfg(feature = "custom_sourcemap")]
300 let mut printer = printer.with_source_map(source_map);
301 #[cfg(not(feature = "custom_sourcemap"))]
302 let mut printer = printer;
303 printer.sources = Some(&self.sources);
304
305 #[cfg(feature = "custom_sourcemap")]
306 if printer.source_map.is_some() {
307 printer.source_maps = self.sources.iter().enumerate().map(|(i, _)| self.source_map::<S>(i)).collect();
308 printer.source_map_source_indices = &self.source_map_source_indices;
309 }
310
311 let (dependencies, exports, references) = self.print(&mut printer, project_root)?;
312 Ok(ToCssResult {
313 dependencies,
314 exports,
315 code: dest,
316 references,
317 })
318 }
319
320 fn print<'a, 'c, P: PrinterTrait>(
321 &'c self,
322 printer: &mut P,
323 project_root: Option<&'a str>,
324 ) -> Result<
325 (
326 Option<Vec<Dependency>>,
327 Option<CssModuleExports>,
328 Option<CssModuleReferences>,
329 ),
330 Error<PrinterErrorKind>,
331 >
332 where
333 'a: 'c,
334 {
335 for comment in &self.license_comments {
336 printer.write_str("/*")?;
337 printer.write_str_with_newlines(comment)?;
338 printer.write_str_with_newlines("*/\n")?;
339 }
340
341 if let Some(config) = &self.options.css_modules {
342 let mut references = CssModuleReferences::new();
343 let css_module = CssModule::new(
344 config,
345 &self.sources,
346 project_root,
347 &mut references,
348 &self.content_hashes,
349 );
350 printer.state_mut().css_module = Some(unsafe { std::mem::transmute(css_module) });
351
352 self.rules.to_css(printer)?;
353 printer.newline()?;
354
355 let dependencies = printer.state_mut().dependencies.take();
356 let mut css_module = printer.state_mut().css_module.take().unwrap();
357 let exports = Some(std::mem::take(&mut css_module.exports_by_source_index[0]));
358
359 Ok((dependencies, exports, Some(references)))
360 } else {
361 self.rules.to_css(printer)?;
362 printer.newline()?;
363
364 let dependencies = printer.state_mut().dependencies.take();
365
366 Ok((dependencies, None, None))
367 }
368 }
369}
370
371#[cfg(feature = "visitor")]
372#[cfg_attr(docsrs, doc(cfg(feature = "visitor")))]
373impl<'i, T, V> Visit<'i, T, V> for StyleSheet<'i, T>
374where
375 T: Visit<'i, T, V>,
376 V: ?Sized + Visitor<'i, T>,
377{
378 const CHILD_TYPES: VisitTypes = VisitTypes::all();
379
380 fn visit(&mut self, visitor: &mut V) -> Result<(), V::Error> {
381 visitor.visit_stylesheet(self)
382 }
383
384 fn visit_children(&mut self, visitor: &mut V) -> Result<(), V::Error> {
385 self.rules.visit(visitor)
386 }
387}
388
389#[cfg_attr(feature = "visitor", derive(Visit))]
415#[cfg_attr(feature = "into_owned", derive(rspack_lightningcss_static_self::IntoOwned))]
416pub struct StyleAttribute<'i> {
417 pub declarations: DeclarationBlock<'i>,
419 #[cfg_attr(feature = "visitor", skip_visit)]
420 sources: Vec<String>,
421}
422
423impl<'i> StyleAttribute<'i> {
424 pub fn parse(code: &'i str, options: ParserOptions<'i>) -> Result<StyleAttribute<'i>, Error<ParserError<'i>>> {
426 let mut input = ParserInput::new(&code);
427 let mut parser = Parser::new(&mut input);
428 Ok(StyleAttribute {
429 declarations: DeclarationBlock::parse(&mut parser, &options).map_err(|e| Error::from(e, "".into()))?,
430 sources: vec![options.filename],
431 })
432 }
433
434 pub fn minify(&mut self, options: MinifyOptions) {
436 let mut context = PropertyHandlerContext::new(options.targets, &options.unused_symbols);
437 let mut handler = DeclarationHandler::default();
438 let mut important_handler = DeclarationHandler::default();
439 context.context = DeclarationContext::StyleAttribute;
440 self.declarations.minify(&mut handler, &mut important_handler, &mut context);
441 }
442
443 pub fn to_css(&self, options: PrinterOptions) -> Result<ToCssResult, PrinterError> {
445 let mut dest = String::with_capacity(1);
447 let mut printer = Printer::new(&mut dest, options);
448 printer.sources = Some(&self.sources);
449
450 self.declarations.to_css(&mut printer)?;
451
452 Ok(ToCssResult {
453 dependencies: printer.take_dependencies(),
454 code: dest,
455 exports: None,
456 references: None,
457 })
458 }
459}