Struct StyleSheet 

pub struct StyleSheet<'i, T = DefaultAtRule> {
    pub rules: CssRuleList<'i, T>,
    pub sources: Vec<String>,
    pub source_map_urls: Vec<Option<String>>,
    pub license_comments: Vec<CowArcStr<'i>>,
    /* private fields */
}

A CSS style sheet, representing a .css file or inline <style> element.

Style sheets can be parsed from a string, constructed from scratch, or created using a Bundler. Then, they can be minified and transformed for a set of target browsers, and serialied to a string.

Example

use lightningcss::stylesheet::{
  StyleSheet, ParserOptions, MinifyOptions, PrinterOptions
};

// Parse a style sheet from a string.
let mut stylesheet = StyleSheet::parse(
  r#"
  .foo {
    color: red;
  }

  .bar {
    color: red;
  }
  "#,
  ParserOptions::default()
).unwrap();

// Minify the stylesheet.
stylesheet.minify(MinifyOptions::default()).unwrap();

// Serialize it to a string.
let res = stylesheet.to_css(PrinterOptions::default()).unwrap();
assert_eq!(res.code, ".foo, .bar {\n  color: red;\n}\n");

Fields

rules: CssRuleList<'i, T>

A list of top-level rules within the style sheet.

sources: Vec<String>

A list of file names for all source files included within the style sheet. Sources are referenced by index in the loc property of each rule.

source_map_urls: Vec<Option<String>>

The source map URL extracted from the original style sheet.

license_comments: Vec<CowArcStr<'i>>

The license comments that appeared at the start of the file.

Implementations

impl<'i, 'o> StyleSheet<'i, DefaultAtRule>

pub fn parse( code: &'i str, options: ParserOptions<'i>, ) -> Result<Self, Error<ParserError<'i>>>

Parse a style sheet from a string.

Examples found in repository

examples/serialize.rs (lines 12-18)

fn parse() {
  use lightningcss::stylesheet::{ParserOptions, StyleSheet};
  use std::{env, fs};

  let args: Vec<String> = env::args().collect();
  let contents = fs::read_to_string(&args[1]).unwrap();
  let stylesheet = StyleSheet::parse(
    &contents,
    ParserOptions {
      filename: args[1].clone(),
      ..ParserOptions::default()
    },
  )
  .unwrap();
  let json = serde_json::to_string(&stylesheet).unwrap();
  println!("{}", json);
}

impl<'i, T> StyleSheet<'i, T>

where T: ToCss + Clone,

pub fn new( sources: Vec<String>, rules: CssRuleList<'i, T>, options: ParserOptions<'i>, ) -> StyleSheet<'i, T>

Creates a new style sheet with the given source filenames and rules.

pub fn parse_with<P: AtRuleParser<'i, AtRule = T>>( code: &'i str, options: ParserOptions<'i>, at_rule_parser: &mut P, ) -> Result<Self, Error<ParserError<'i>>>

Parse a style sheet from a string.

Examples found in repository

examples/custom_at_rule.rs (line 31)

fn main() {
  let args: Vec<String> = std::env::args().collect();
  let source = std::fs::read_to_string(&args[1]).unwrap();
  let opts = ParserOptions {
    filename: args[1].clone(),
    ..Default::default()
  };

  let mut stylesheet = StyleSheet::parse_with(&source, opts, &mut TailwindAtRuleParser).unwrap();

  println!("{:?}", stylesheet);

  let mut style_rules = HashMap::new();
  stylesheet
    .visit(&mut StyleRuleCollector {
      rules: &mut style_rules,
    })
    .unwrap();
  println!("{:?}", style_rules);
  stylesheet.visit(&mut ApplyVisitor { rules: &style_rules }).unwrap();

  let result = stylesheet
    .to_css(PrinterOptions {
      targets: Browsers {
        chrome: Some(100 << 16),
        ..Browsers::default()
      }
      .into(),
      ..PrinterOptions::default()
    })
    .unwrap();
  println!("{}", result.code);
}

pub fn source_map_url(&self, source_index: usize) -> Option<&String>

Returns the source map URL for the source at the given index.

pub fn source_map(&self, source_index: usize) -> Option<SourceMap>

Available on crate feature sourcemap only.

Returns the inline source map associated with the source at the given index.

pub fn minify( &mut self, options: MinifyOptions, ) -> Result<(), Error<MinifyErrorKind>>

Minify and transform the style sheet for the provided browser targets.

Examples found in repository

examples/vize_bundler_before_observer.rs (line 42)

fn observe(case: &Value, provider: &Provider) -> Value {
  let mut map = SourceMap::new("/");
  let options = ParserOptions {
    css_modules: case["cssModules"].as_bool().unwrap_or(false).then(|| Config {
      dashed_idents: true,
      pattern: Pattern::parse("[hash]_[local]").unwrap(),
      ..Default::default()
    }),
    ..Default::default()
  };
  let mut bundler = Bundler::new(provider, Some(&mut map), options);
  let result = match bundler.bundle(Path::new(case["entry"].as_str().unwrap())) {
    Ok(mut stylesheet) => {
      // Preserve pre-minification source/map/comment/context metadata too.
      let bundle = json!({
        "ast": stylesheet,
        "sources": stylesheet.sources,
        "sourceMapUrls": stylesheet.source_map_urls,
        "licenseComments": stylesheet.license_comments,
        "privateContentHashesObserved": false,
      });
      let minify_error = if case["minify"].as_bool().unwrap_or(false) {
        stylesheet.minify(MinifyOptions::default()).err()
      } else {
        None
      };
      if let Some(value) = minify_error {
        json!({"bundle": bundle, "error": error("minify", value)})
      } else {
        match stylesheet.to_css(PrinterOptions {
          source_map: Some(&mut map),
          ..Default::default()
        }) {
          Ok(result) => json!({
            "bundle": bundle, "code": result.code, "exports": result.exports,
            "references": result.references, "dependencies": result.dependencies,
          }),
          Err(value) => json!({"bundle": bundle, "error": error("print", value)}),
        }
      }
    }
    Err(value) => json!({"error": error("bundle", value)}),
  };
  let mappings: Vec<Value> = map
    .get_mappings()
    .iter()
    .map(|mapping| {
      json!({
        "generatedLine": mapping.generated_line,
        "generatedColumn": mapping.generated_column,
        "original": mapping.original.map(|value| json!({
          "line": value.original_line, "column": value.original_column,
          "source": value.source, "name": value.name,
        })),
      })
    })
    .collect();
  json!({
    "result": result,
    "map": {"json": map.to_json(None).unwrap(), "sources": map.get_sources(),
      "sourcesContent": map.get_sources_content(), "names": map.get_names(), "mappings": mappings},
  })
}

pub fn to_css( &self, options: PrinterOptions<'_>, ) -> Result<ToCssResult, Error<PrinterErrorKind>>

Serialize the style sheet to a CSS string.

Examples found in repository

examples/custom_at_rule.rs (lines 45-52)

fn main() {
  let args: Vec<String> = std::env::args().collect();
  let source = std::fs::read_to_string(&args[1]).unwrap();
  let opts = ParserOptions {
    filename: args[1].clone(),
    ..Default::default()
  };

  let mut stylesheet = StyleSheet::parse_with(&source, opts, &mut TailwindAtRuleParser).unwrap();

  println!("{:?}", stylesheet);

  let mut style_rules = HashMap::new();
  stylesheet
    .visit(&mut StyleRuleCollector {
      rules: &mut style_rules,
    })
    .unwrap();
  println!("{:?}", style_rules);
  stylesheet.visit(&mut ApplyVisitor { rules: &style_rules }).unwrap();

  let result = stylesheet
    .to_css(PrinterOptions {
      targets: Browsers {
        chrome: Some(100 << 16),
        ..Browsers::default()
      }
      .into(),
      ..PrinterOptions::default()
    })
    .unwrap();
  println!("{}", result.code);
}

examples/vize_bundler_before_observer.rs (lines 49-52)

fn observe(case: &Value, provider: &Provider) -> Value {
  let mut map = SourceMap::new("/");
  let options = ParserOptions {
    css_modules: case["cssModules"].as_bool().unwrap_or(false).then(|| Config {
      dashed_idents: true,
      pattern: Pattern::parse("[hash]_[local]").unwrap(),
      ..Default::default()
    }),
    ..Default::default()
  };
  let mut bundler = Bundler::new(provider, Some(&mut map), options);
  let result = match bundler.bundle(Path::new(case["entry"].as_str().unwrap())) {
    Ok(mut stylesheet) => {
      // Preserve pre-minification source/map/comment/context metadata too.
      let bundle = json!({
        "ast": stylesheet,
        "sources": stylesheet.sources,
        "sourceMapUrls": stylesheet.source_map_urls,
        "licenseComments": stylesheet.license_comments,
        "privateContentHashesObserved": false,
      });
      let minify_error = if case["minify"].as_bool().unwrap_or(false) {
        stylesheet.minify(MinifyOptions::default()).err()
      } else {
        None
      };
      if let Some(value) = minify_error {
        json!({"bundle": bundle, "error": error("minify", value)})
      } else {
        match stylesheet.to_css(PrinterOptions {
          source_map: Some(&mut map),
          ..Default::default()
        }) {
          Ok(result) => json!({
            "bundle": bundle, "code": result.code, "exports": result.exports,
            "references": result.references, "dependencies": result.dependencies,
          }),
          Err(value) => json!({"bundle": bundle, "error": error("print", value)}),
        }
      }
    }
    Err(value) => json!({"error": error("bundle", value)}),
  };
  let mappings: Vec<Value> = map
    .get_mappings()
    .iter()
    .map(|mapping| {
      json!({
        "generatedLine": mapping.generated_line,
        "generatedColumn": mapping.generated_column,
        "original": mapping.original.map(|value| json!({
          "line": value.original_line, "column": value.original_column,
          "source": value.source, "name": value.name,
        })),
      })
    })
    .collect();
  json!({
    "result": result,
    "map": {"json": map.to_json(None).unwrap(), "sources": map.get_sources(),
      "sourcesContent": map.get_sources_content(), "names": map.get_names(), "mappings": mappings},
  })
}

Trait Implementations

impl<'i, T: Clone> Clone for StyleSheet<'i, T>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'i, T: Debug> Debug for StyleSheet<'i, T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de: 'i, 'i, T> Deserialize<'de> for StyleSheet<'i, T>

where T: Deserialize<'de>,

Available on crate feature serde only.

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'any, 'i, T> IntoOwned<'any> for StyleSheet<'i, T>

where T: IntoOwned<'any>,

Available on crate feature into_owned only.

fn into_owned(self) -> Self::Owned

Consumes the value and returns an owned clone.

type Owned = StyleSheet<'any, <T as IntoOwned<'any>>::Owned>

A variant of Self with a new lifetime.

impl<'i, T> JsonSchema for StyleSheet<'i, T>

where T: JsonSchema,

Available on crate feature jsonschema only.

fn schema_name() -> String

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

impl<'i, T> Serialize for StyleSheet<'i, T>

where T: Serialize,

Available on crate feature serde only.

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'i, T, V> Visit<'i, T, V> for StyleSheet<'i, T>

where T: Visit<'i, T, V>, V: ?Sized + Visitor<'i, T>,

Available on crate feature visitor only.

const CHILD_TYPES: VisitTypes

The types of values contained within this value and its children. This is used to skip branches that don’t have any values requested by the Visitor.

fn visit(&mut self, visitor: &mut V) -> Result<(), V::Error>

Visits the value by calling an appropriate method on the Visitor. If no corresponding visitor method exists, then the children are visited.

fn visit_children(&mut self, visitor: &mut V) -> Result<(), V::Error>

Visit the children of this value.