rspack_plugin_css 0.100.0

rspack css plugin
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

use std::fmt::Display;

use rspack_cacheable::{cacheable, cacheable_dyn};
use rspack_core::{
  AsContextDependency, Dependency, DependencyCategory, DependencyCodeGeneration, DependencyId,
  DependencyRange, DependencyTemplate, DependencyTemplateType, DependencyType, FactorizeInfo,
  ModuleDependency, TemplateContext, TemplateReplaceSource,
};

#[cacheable]
#[derive(Debug, Clone)]
pub struct CssImportDependency {
  id: DependencyId,
  request: String,
  range: DependencyRange,
  media: Option<String>,
  supports: Option<String>,
  layer: Option<CssLayer>,
  factorize_info: FactorizeInfo,
}

#[cacheable]
#[derive(Debug, Clone)]
pub enum CssLayer {
  Anonymous,
  Named(String),
}

impl CssImportDependency {
  pub fn new(
    request: String,
    range: DependencyRange,
    media: Option<String>,
    supports: Option<String>,
    layer: Option<CssLayer>,
  ) -> Self {
    Self {
      id: DependencyId::new(),
      request,
      range,
      media,
      supports,
      layer,
      factorize_info: Default::default(),
    }
  }

  pub fn media(&self) -> Option<&str> {
    self.media.as_deref()
  }

  pub fn supports(&self) -> Option<&str> {
    self.supports.as_deref()
  }

  pub fn layer(&self) -> Option<&CssLayer> {
    self.layer.as_ref()
  }
}

#[cacheable_dyn]
impl Dependency for CssImportDependency {
  fn id(&self) -> &DependencyId {
    &self.id
  }

  fn category(&self) -> &DependencyCategory {
    &DependencyCategory::CssImport
  }

  fn dependency_type(&self) -> &DependencyType {
    &DependencyType::CssImport
  }

  fn range(&self) -> Option<DependencyRange> {
    Some(self.range)
  }

  fn could_affect_referencing_module(&self) -> rspack_core::AffectType {
    rspack_core::AffectType::True
  }
}

#[cacheable_dyn]
impl ModuleDependency for CssImportDependency {
  fn request(&self) -> &str {
    &self.request
  }

  fn user_request(&self) -> &str {
    &self.request
  }

  fn factorize_info(&self) -> &FactorizeInfo {
    &self.factorize_info
  }

  fn factorize_info_mut(&mut self) -> &mut FactorizeInfo {
    &mut self.factorize_info
  }
}

#[derive(Clone)]
pub struct CssMedia(pub String);

#[derive(Clone)]
pub struct CssSupports(pub String);

impl Display for CssMedia {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    self.0.fmt(f)
  }
}

impl Display for CssSupports {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    self.0.fmt(f)
  }
}

#[cacheable_dyn]
impl DependencyCodeGeneration for CssImportDependency {
  fn dependency_template(&self) -> Option<DependencyTemplateType> {
    Some(CssImportDependencyTemplate::template_type())
  }
}

impl AsContextDependency for CssImportDependency {}

#[cacheable]
#[derive(Debug, Clone, Default)]
pub struct CssImportDependencyTemplate;
impl CssImportDependencyTemplate {
  pub fn template_type() -> DependencyTemplateType {
    DependencyTemplateType::Dependency(DependencyType::CssImport)
  }
}

impl DependencyTemplate for CssImportDependencyTemplate {
  fn render(
    &self,
    dep: &dyn DependencyCodeGeneration,
    source: &mut TemplateReplaceSource,
    _code_generatable_context: &mut TemplateContext,
  ) {
    let dep = dep
      .as_any()
      .downcast_ref::<CssImportDependency>()
      .expect("CssImportDependencyTemplate should be used for CssImportDependency");

    source.replace_static(dep.range.start, dep.range.end, "", None);
  }
}