Struct Pattern 

pub struct Pattern {
    pub segments: SmallVec<[Segment; 2]>,
}

A CSS modules class name pattern.

Fields

segments: SmallVec<[Segment; 2]>

The list of segments in the pattern.

Implementations

impl Pattern

pub fn parse(input: &str) -> Result<Self, PatternParseError>

Parse a pattern from a string.

Examples found in repository

examples/vize_bundler_before_observer.rs (line 25)

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 has_content_hash(&self) -> bool

Whether the pattern contains any [content-hash] segments.

pub fn write<W, E>( &self, hash: &str, path: &Path, local: &str, content_hash: &str, write: W, ) -> Result<(), E>

where W: FnMut(&str) -> Result<(), E>,

Write the substituted pattern to a destination.

Trait Implementations

impl Clone for Pattern

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Pattern

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

Formats the value using the given formatter.

impl Default for Pattern

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for Pattern

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Pattern