rspack_lightningcss/rules/
font_feature_values.rs1use 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#[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 #[cfg_attr(feature = "serde", serde(borrow))]
25 pub name: Vec<FamilyName<'i>>,
26 pub rules: IndexMap<FontFeatureSubruleType, FontFeatureSubrule<'i>>,
28 #[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#[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,
201 HistoricalForms,
203 Styleset,
205 CharacterVariant,
207 Swash,
209 Ornaments,
211 Annotation,
213}
214
215#[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 pub name: FontFeatureSubruleType,
229 #[cfg_attr(feature = "serde", serde(borrow))]
231 pub declarations: IndexMap<Ident<'i>, SmallVec<[CSSInteger; 1]>>,
232 #[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
303impl<'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}