Struct Bundler 

pub struct Bundler<'a, 's, P, T: AtRuleParser<'a>> { /* private fields */ }

Available on crate feature bundler only.

A Bundler combines a CSS file and all imported dependencies together into a single merged style sheet.

Implementations

impl<'a, 's, P: SourceProvider> Bundler<'a, 's, P, DefaultAtRuleParser>

pub fn new( fs: &'a P, source_map: Option<&'s mut SourceMap>, options: ParserOptions<'a>, ) -> Bundler<'a, 's, P, DefaultAtRuleParser>

Creates a new Bundler using the given source provider. If a source map is given, the content of each source file included in the bundle will be added accordingly.

Examples found in repository

examples/vize_bundler_before_observer.rs (line 30)

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},
  })
}

impl<'a, 's, P: SourceProvider, T: AtRuleParser<'a> + Clone + Sync + Send> Bundler<'a, 's, P, T>

where T::AtRule: Sync + Send + ToCss + Clone,

pub fn new_with_at_rule_parser( fs: &'a P, source_map: Option<&'s mut SourceMap>, options: ParserOptions<'a>, at_rule_parser: &'s mut T, ) -> Self

Creates a new Bundler using the given source provider. If a source map is given, the content of each source file included in the bundle will be added accordingly.

pub fn bundle<'e>( &mut self, entry: &'e Path, ) -> Result<StyleSheet<'a, T::AtRule>, Error<BundleErrorKind<'a, P::Error>>>

Bundles the given entry file and all dependencies into a single style sheet.

Examples found in repository

examples/vize_bundler_before_observer.rs (line 31)

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},
  })
}