use crate::css_modules::CssModule;
use crate::dependencies::{Dependency, DependencyOptions};
use crate::error::{Error, ErrorLocation, PrinterError, PrinterErrorKind};
use crate::rules::{Location, StyleContext};
use crate::selector::SelectorList;
use crate::targets::Browsers;
use crate::vendor_prefix::VendorPrefix;
use cssparser::{serialize_identifier, serialize_name};
#[cfg(feature = "sourcemap")]
use parcel_sourcemap::{OriginalLocation, SourceMap};
#[derive(Default)]
pub struct PrinterOptions<'a> {
pub minify: bool,
#[cfg(feature = "sourcemap")]
#[cfg_attr(docsrs, doc(cfg(feature = "sourcemap")))]
pub source_map: Option<&'a mut SourceMap>,
pub project_root: Option<&'a str>,
pub targets: Option<Browsers>,
pub analyze_dependencies: Option<DependencyOptions>,
pub pseudo_classes: Option<PseudoClasses<'a>>,
}
#[derive(Default, Debug)]
pub struct PseudoClasses<'a> {
pub hover: Option<&'a str>,
pub active: Option<&'a str>,
pub focus: Option<&'a str>,
pub focus_visible: Option<&'a str>,
pub focus_within: Option<&'a str>,
}
pub struct Printer<'a, 'b, 'c, W> {
pub(crate) sources: Option<&'c Vec<String>>,
dest: &'a mut W,
#[cfg(feature = "sourcemap")]
#[cfg_attr(docsrs, doc(cfg(feature = "sourcemap")))]
pub(crate) source_map: Option<&'a mut SourceMap>,
#[cfg(feature = "sourcemap")]
#[cfg_attr(docsrs, doc(cfg(feature = "sourcemap")))]
pub(crate) source_maps: Vec<Option<SourceMap>>,
pub(crate) loc: Location,
indent: u8,
line: u32,
col: u32,
pub(crate) minify: bool,
pub(crate) targets: Option<Browsers>,
pub(crate) vendor_prefix: VendorPrefix,
pub(crate) in_calc: bool,
pub(crate) css_module: Option<CssModule<'a, 'b, 'c>>,
pub(crate) dependencies: Option<Vec<Dependency>>,
pub(crate) remove_imports: bool,
pub(crate) pseudo_classes: Option<PseudoClasses<'a>>,
context: Option<&'a StyleContext<'a, 'b>>,
}
impl<'a, 'b, 'c, W: std::fmt::Write + Sized> Printer<'a, 'b, 'c, W> {
pub fn new(dest: &'a mut W, options: PrinterOptions<'a>) -> Self {
Printer {
sources: None,
dest,
#[cfg(feature = "sourcemap")]
source_map: options.source_map,
#[cfg(feature = "sourcemap")]
source_maps: Vec::new(),
loc: Location {
source_index: 0,
line: 0,
column: 1,
},
indent: 0,
line: 0,
col: 0,
minify: options.minify,
targets: options.targets,
vendor_prefix: VendorPrefix::empty(),
in_calc: false,
css_module: None,
dependencies: if options.analyze_dependencies.is_some() {
Some(Vec::new())
} else {
None
},
remove_imports: matches!(&options.analyze_dependencies, Some(d) if d.remove_imports),
pseudo_classes: options.pseudo_classes,
context: None,
}
}
pub fn filename(&self) -> &'c str {
if let Some(sources) = self.sources {
if let Some(f) = sources.get(self.loc.source_index as usize) {
f
} else {
"unknown.css"
}
} else {
"unknown.css"
}
}
pub fn write_str(&mut self, s: &str) -> Result<(), PrinterError> {
self.col += s.len() as u32;
self.dest.write_str(s)?;
Ok(())
}
pub fn write_char(&mut self, c: char) -> Result<(), PrinterError> {
if c == '\n' {
self.line += 1;
self.col = 0;
} else {
self.col += 1;
}
self.dest.write_char(c)?;
Ok(())
}
pub fn whitespace(&mut self) -> Result<(), PrinterError> {
if self.minify {
return Ok(());
}
self.write_char(' ')
}
pub fn delim(&mut self, delim: char, ws_before: bool) -> Result<(), PrinterError> {
if ws_before {
self.whitespace()?;
}
self.write_char(delim)?;
self.whitespace()
}
pub fn newline(&mut self) -> Result<(), PrinterError> {
if self.minify {
return Ok(());
}
self.write_char('\n')?;
if self.indent > 0 {
self.write_str(&" ".repeat(self.indent as usize))?;
}
Ok(())
}
pub fn indent(&mut self) {
self.indent += 2;
}
pub fn dedent(&mut self) {
self.indent -= 2;
}
pub fn indent_by(&mut self, amt: u8) {
self.indent += amt;
}
pub fn dedent_by(&mut self, amt: u8) {
self.indent -= amt;
}
pub fn is_nested(&self) -> bool {
self.indent > 2
}
#[cfg(feature = "sourcemap")]
#[cfg_attr(docsrs, doc(cfg(feature = "sourcemap")))]
pub fn add_mapping(&mut self, loc: Location) {
self.loc = loc;
if let Some(map) = &mut self.source_map {
let mut original = OriginalLocation {
original_line: loc.line,
original_column: loc.column - 1,
source: loc.source_index,
name: None,
};
if let Some(Some(sm)) = self.source_maps.get_mut(loc.source_index as usize) {
let mut found_mapping = false;
if let Some(mapping) = sm.find_closest_mapping(loc.line, loc.column - 1) {
if let Some(orig) = mapping.original {
let sources_len = map.get_sources().len();
let source_index = map.add_source(sm.get_source(orig.source).unwrap());
original.original_line = orig.original_line;
original.original_column = orig.original_column;
original.source = source_index;
original.name = orig.name;
if map.get_sources().len() > sources_len {
let content = sm.get_source_content(orig.source).unwrap().to_owned();
let _ = map.set_source_content(source_index as usize, &content);
}
found_mapping = true;
}
}
if !found_mapping {
return;
}
}
map.add_mapping(self.line, self.col, Some(original))
}
}
pub fn write_ident(&mut self, ident: &str) -> Result<(), PrinterError> {
if let Some(css_module) = &mut self.css_module {
let dest = &mut self.dest;
let mut first = true;
css_module.config.pattern.write(
&css_module.hashes[self.loc.source_index as usize],
&css_module.sources[self.loc.source_index as usize],
ident,
|s| {
self.col += s.len() as u32;
if first {
first = false;
serialize_identifier(s, dest)
} else {
serialize_name(s, dest)
}
},
)?;
css_module.add_local(&ident, &ident, self.loc.source_index);
} else {
serialize_identifier(ident, self)?;
}
Ok(())
}
pub(crate) fn write_dashed_ident(&mut self, ident: &str, is_declaration: bool) -> Result<(), PrinterError> {
self.write_str("--")?;
match &mut self.css_module {
Some(css_module) if css_module.config.dashed_idents => {
let dest = &mut self.dest;
css_module.config.pattern.write(
&css_module.hashes[self.loc.source_index as usize],
&css_module.sources[self.loc.source_index as usize],
&ident[2..],
|s| {
self.col += s.len() as u32;
serialize_name(s, dest)
},
)?;
if is_declaration {
css_module.add_dashed(ident, self.loc.source_index);
}
}
_ => {
serialize_name(&ident[2..], self)?;
}
}
Ok(())
}
pub fn error(&self, kind: PrinterErrorKind, loc: crate::dependencies::Location) -> Error<PrinterErrorKind> {
Error {
kind,
loc: Some(ErrorLocation {
filename: self.filename().into(),
line: loc.line - 1,
column: loc.column,
}),
}
}
pub(crate) fn with_context<T, U, F: FnOnce(&mut Printer<'a, 'b, 'c, W>) -> Result<T, U>>(
&mut self,
selectors: &SelectorList,
f: F,
) -> Result<T, U> {
let parent = std::mem::take(&mut self.context);
let ctx = StyleContext {
selectors: unsafe { std::mem::transmute(selectors) },
parent,
};
self.context = Some(unsafe { std::mem::transmute(&ctx) });
let res = f(self);
self.context = parent;
res
}
pub(crate) fn context(&self) -> Option<&'a StyleContext<'a, 'b>> {
self.context.clone()
}
}
impl<'a, 'b, 'c, W: std::fmt::Write + Sized> std::fmt::Write for Printer<'a, 'b, 'c, W> {
fn write_str(&mut self, s: &str) -> std::fmt::Result {
self.col += s.len() as u32;
self.dest.write_str(s)
}
}