Skip to main content

rspack_lightningcss/rules/
font_feature_values.rs

1//! The `@font-feature-values` rule.
2
3use super::Location;
4use crate::error::{ParserError, PrinterError};
5use crate::parser::ParserOptions;
6use crate::properties::font::FamilyName;
7use crate::traits::{Parse, ToCss};
8use crate::values::ident::Ident;
9use crate::values::number::CSSInteger;
10#[cfg(feature = "visitor")]
11use crate::visitor::Visit;
12use cssparser::*;
13use indexmap::IndexMap;
14use smallvec::SmallVec;
15
16/// A [@font-feature-values](https://drafts.csswg.org/css-fonts/#font-feature-values) rule.
17#[derive(Debug, PartialEq, Clone)]
18#[cfg_attr(feature = "visitor", derive(Visit))]
19#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
20#[cfg_attr(feature = "jsonschema", derive(schemars::JsonSchema))]
21#[cfg_attr(feature = "into_owned", derive(rspack_lightningcss_static_self::IntoOwned))]
22pub struct FontFeatureValuesRule<'i> {
23  /// The name of the font feature values.
24  #[cfg_attr(feature = "serde", serde(borrow))]
25  pub name: Vec<FamilyName<'i>>,
26  /// The rules within the `@font-feature-values` rule.
27  pub rules: IndexMap<FontFeatureSubruleType, FontFeatureSubrule<'i>>,
28  /// The location of the rule in the source file.
29  #[cfg_attr(feature = "visitor", skip_visit)]
30  pub loc: Location,
31}
32
33impl<'i> FontFeatureValuesRule<'i> {
34  pub(crate) fn parse<'t>(
35    family_names: Vec<FamilyName<'i>>,
36    input: &mut Parser<'i, 't>,
37    loc: Location,
38    options: &ParserOptions<'i>,
39  ) -> Result<Self, ParseError<'i, ParserError<'i>>> {
40    let mut rules = IndexMap::new();
41    let mut rule_parser = FontFeatureValuesRuleParser {
42      rules: &mut rules,
43      options,
44    };
45    let mut parser = RuleBodyParser::new(input, &mut rule_parser);
46
47    while let Some(decl_or_rule) = parser.next() {
48      if let Err((err, _)) = decl_or_rule {
49        if parser.parser.options.error_recovery {
50          parser.parser.options.warn(err);
51          continue;
52        }
53        return Err(err);
54      }
55    }
56
57    Ok(FontFeatureValuesRule {
58      name: family_names,
59      rules,
60      loc,
61    })
62  }
63}
64
65struct FontFeatureValuesRuleParser<'a, 'i> {
66  rules: &'a mut IndexMap<FontFeatureSubruleType, FontFeatureSubrule<'i>>,
67  options: &'a ParserOptions<'i>,
68}
69
70impl<'a, 'i> cssparser::DeclarationParser<'i> for FontFeatureValuesRuleParser<'a, 'i> {
71  type Declaration = ();
72  type Error = ParserError<'i>;
73}
74
75impl<'a, 'i> cssparser::AtRuleParser<'i> for FontFeatureValuesRuleParser<'a, 'i> {
76  type Prelude = FontFeatureSubruleType;
77  type AtRule = ();
78  type Error = ParserError<'i>;
79
80  fn parse_prelude<'t>(
81    &mut self,
82    name: CowRcStr<'i>,
83    input: &mut Parser<'i, 't>,
84  ) -> Result<Self::Prelude, ParseError<'i, Self::Error>> {
85    let loc = input.current_source_location();
86    FontFeatureSubruleType::parse_string(&name)
87      .map_err(|_| loc.new_custom_error(ParserError::AtRuleInvalid(name.clone().into())))
88  }
89
90  fn parse_block<'t>(
91    &mut self,
92    prelude: Self::Prelude,
93    start: &ParserState,
94    input: &mut Parser<'i, 't>,
95  ) -> Result<Self::AtRule, ParseError<'i, Self::Error>> {
96    let loc = start.source_location();
97    let mut decls = IndexMap::new();
98    let mut has_existing = false;
99    let declarations = if let Some(rule) = self.rules.get_mut(&prelude) {
100      has_existing = true;
101      &mut rule.declarations
102    } else {
103      &mut decls
104    };
105    let mut decl_parser = FontFeatureDeclarationParser { declarations };
106    let mut parser = RuleBodyParser::new(input, &mut decl_parser);
107    while let Some(decl) = parser.next() {
108      if let Err((err, _)) = decl {
109        if self.options.error_recovery {
110          self.options.warn(err);
111          continue;
112        }
113        return Err(err);
114      }
115    }
116
117    if !has_existing {
118      self.rules.insert(
119        prelude,
120        FontFeatureSubrule {
121          name: prelude,
122          declarations: decls,
123          loc: Location {
124            source_index: self.options.source_index,
125            line: loc.line,
126            column: loc.column,
127          },
128        },
129      );
130    }
131
132    Ok(())
133  }
134}
135
136impl<'a, 'i> QualifiedRuleParser<'i> for FontFeatureValuesRuleParser<'a, 'i> {
137  type Prelude = ();
138  type QualifiedRule = ();
139  type Error = ParserError<'i>;
140}
141
142impl<'a, 'i> RuleBodyItemParser<'i, (), ParserError<'i>> for FontFeatureValuesRuleParser<'a, 'i> {
143  fn parse_declarations(&self) -> bool {
144    false
145  }
146
147  fn parse_qualified(&self) -> bool {
148    false
149  }
150}
151
152impl<'i> ToCss for FontFeatureValuesRule<'i> {
153  fn to_css<PrinterT: crate::printer::PrinterTrait>(&self, dest: &mut PrinterT) -> Result<(), PrinterError> {
154    dest.add_mapping(self.loc);
155    dest.write_str("@font-feature-values ")?;
156    self.name.to_css(dest)?;
157    dest.whitespace()?;
158    dest.write_char('{')?;
159    if !self.rules.is_empty() {
160      dest.newline()?;
161      for rule in self.rules.values() {
162        rule.to_css(dest)?;
163        dest.newline()?;
164      }
165    }
166    dest.write_char('}')?;
167    Ok(())
168  }
169}
170
171impl<'i> FontFeatureValuesRule<'i> {
172  pub(crate) fn merge(&mut self, other: &FontFeatureValuesRule<'i>) {
173    debug_assert_eq!(self.name, other.name);
174    for (prelude, rule) in &other.rules {
175      if let Some(existing) = self.rules.get_mut(prelude) {
176        existing
177          .declarations
178          .extend(rule.declarations.iter().map(|(k, v)| (k.clone(), v.clone())));
179      } else {
180        self.rules.insert(*prelude, rule.clone());
181      }
182    }
183  }
184}
185
186/// The name of the `@font-feature-values` sub-rule.
187/// font-feature-value-type = <@stylistic> | <@historical-forms> | <@styleset> | <@character-variant>
188///   | <@swash> | <@ornaments> | <@annotation>
189#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Parse, ToCss)]
190#[cfg_attr(feature = "visitor", derive(Visit))]
191#[cfg_attr(
192  feature = "serde",
193  derive(serde::Serialize, serde::Deserialize),
194  serde(rename_all = "kebab-case")
195)]
196#[cfg_attr(feature = "jsonschema", derive(schemars::JsonSchema))]
197#[cfg_attr(feature = "into_owned", derive(rspack_lightningcss_static_self::IntoOwned))]
198pub enum FontFeatureSubruleType {
199  /// @stylistic = @stylistic { <declaration-list> }
200  Stylistic,
201  /// @historical-forms = @historical-forms { <declaration-list> }
202  HistoricalForms,
203  /// @styleset = @styleset { <declaration-list> }
204  Styleset,
205  /// @character-variant = @character-variant { <declaration-list> }
206  CharacterVariant,
207  /// @swash = @swash { <declaration-list> }
208  Swash,
209  /// @ornaments = @ornaments { <declaration-list> }
210  Ornaments,
211  /// @annotation = @annotation { <declaration-list> }
212  Annotation,
213}
214
215/// A sub-rule of `@font-feature-values`
216/// https://drafts.csswg.org/css-fonts/#font-feature-values-syntax
217#[derive(Debug, PartialEq, Clone)]
218#[cfg_attr(feature = "visitor", derive(Visit))]
219#[cfg_attr(feature = "into_owned", derive(rspack_lightningcss_static_self::IntoOwned))]
220#[cfg_attr(
221  feature = "serde",
222  derive(serde::Serialize, serde::Deserialize),
223  serde(rename_all = "camelCase")
224)]
225#[cfg_attr(feature = "jsonschema", derive(schemars::JsonSchema))]
226pub struct FontFeatureSubrule<'i> {
227  /// The name of the `@font-feature-values` sub-rule.
228  pub name: FontFeatureSubruleType,
229  /// The declarations within the `@font-feature-values` sub-rules.
230  #[cfg_attr(feature = "serde", serde(borrow))]
231  pub declarations: IndexMap<Ident<'i>, SmallVec<[CSSInteger; 1]>>,
232  /// The location of the rule in the source file.
233  #[cfg_attr(feature = "visitor", skip_visit)]
234  pub loc: Location,
235}
236
237impl<'i> ToCss for FontFeatureSubrule<'i> {
238  fn to_css<PrinterT: crate::printer::PrinterTrait>(&self, dest: &mut PrinterT) -> Result<(), PrinterError> {
239    dest.add_mapping(self.loc);
240    dest.write_char('@')?;
241    self.name.to_css(dest)?;
242    dest.write_char('{')?;
243    dest.indent();
244    let len = self.declarations.len();
245    for (i, (name, value)) in self.declarations.iter().enumerate() {
246      dest.newline()?;
247      name.to_css(dest)?;
248      dest.delim(':', false)?;
249
250      let mut first = true;
251      for index in value {
252        if first {
253          first = false;
254        } else {
255          dest.write_char(' ')?;
256        }
257        index.to_css(dest)?;
258      }
259
260      if i != len - 1 || !dest.options().minify {
261        dest.write_char(';')?;
262      }
263    }
264    dest.dedent();
265    dest.newline()?;
266    dest.write_char('}')?;
267    Ok(())
268  }
269}
270
271struct FontFeatureDeclarationParser<'a, 'i> {
272  declarations: &'a mut IndexMap<Ident<'i>, SmallVec<[CSSInteger; 1]>>,
273}
274
275impl<'a, 'i> cssparser::DeclarationParser<'i> for FontFeatureDeclarationParser<'a, 'i> {
276  type Declaration = ();
277  type Error = ParserError<'i>;
278
279  fn parse_value<'t>(
280    &mut self,
281    name: CowRcStr<'i>,
282    input: &mut cssparser::Parser<'i, 't>,
283    _declaration_start: &ParserState,
284  ) -> Result<Self::Declaration, cssparser::ParseError<'i, Self::Error>> {
285    let mut indices = SmallVec::new();
286    loop {
287      if let Ok(value) = CSSInteger::parse(input) {
288        indices.push(value);
289      } else {
290        break;
291      }
292    }
293
294    if indices.is_empty() {
295      return Err(input.new_custom_error(ParserError::InvalidValue));
296    }
297
298    self.declarations.insert(Ident(name.into()), indices);
299    Ok(())
300  }
301}
302
303/// Default methods reject all at rules.
304impl<'a, 'i> AtRuleParser<'i> for FontFeatureDeclarationParser<'a, 'i> {
305  type Prelude = ();
306  type AtRule = ();
307  type Error = ParserError<'i>;
308}
309
310impl<'a, 'i> QualifiedRuleParser<'i> for FontFeatureDeclarationParser<'a, 'i> {
311  type Prelude = ();
312  type QualifiedRule = ();
313  type Error = ParserError<'i>;
314}
315
316impl<'a, 'i> RuleBodyItemParser<'i, (), ParserError<'i>> for FontFeatureDeclarationParser<'a, 'i> {
317  fn parse_qualified(&self) -> bool {
318    false
319  }
320
321  fn parse_declarations(&self) -> bool {
322    true
323  }
324}