blitz-pdf 0.0.0-stage → 0.1.0

package/vendor/stylo/values/specified/frequency.rs

@@ -0,0 +1,39 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+//! Specified frequency values.
+
+use crate::derives::*;
+use cssparser::match_ignore_ascii_case;
+
+/// The unit of a `<frequency>` value.
+#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq, PartialOrd, ToShmem)]
+#[repr(u8)]
+pub enum FrequencyUnit {
+    /// `Hz`
+    Hz,
+    /// `kHz`
+    Khz,
+}
+
+impl FrequencyUnit {
+    /// Returns the frequency unit for the given string.
+    #[inline]
+    pub fn from_str(unit: &str) -> Result<Self, ()> {
+        Ok(match_ignore_ascii_case! { unit,
+            "hz" => Self::Hz,
+            "khz" => Self::Khz,
+             _ => return Err(())
+        })
+    }
+
+    /// Returns this unit as a string.
+    #[inline]
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::Hz => "hz",
+            Self::Khz => "khz",
+        }
+    }
+}

package/vendor/stylo/values/specified/grid.rs

@@ -0,0 +1,407 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+//! CSS handling for the computed value of
+//! [grids](https://drafts.csswg.org/css-grid/)
+
+use crate::derives::*;
+use crate::parser::{Parse, ParserContext};
+use crate::values::generics::grid::{
+    Flex, FlexUnit, GridTemplateComponent, ImplicitGridTracks, RepeatCount,
+};
+use crate::values::generics::grid::{LineNameList, LineNameListValue, NameRepeat, TrackBreadth};
+use crate::values::generics::grid::{TrackList, TrackListValue, TrackRepeat, TrackSize};
+use crate::values::specified::{Integer, LengthPercentage};
+use crate::values::CustomIdent;
+use cssparser::{Parser, Token};
+use style_traits::{ParseError, StyleParseErrorKind};
+
+impl Flex {
+    /// Parse a single flexible length.
+    fn parse(input: &mut Parser) -> Result<Self, ParseError> {
+        match *input.next()? {
+            Token::Dimension {
+                value, ref unit, ..
+            } if FlexUnit::matches(unit) && value.is_sign_positive() => Ok(Self(value)),
+            _ => Err(ParseError::unexpected_token()),
+        }
+    }
+}
+
+impl<L> TrackBreadth<L> {
+    fn parse_keyword(input: &mut Parser) -> Result<Self, ParseError> {
+        #[derive(Parse)]
+        enum TrackKeyword {
+            Auto,
+            MaxContent,
+            MinContent,
+        }
+
+        Ok(match TrackKeyword::parse(input)? {
+            TrackKeyword::Auto => TrackBreadth::Auto,
+            TrackKeyword::MaxContent => TrackBreadth::MaxContent,
+            TrackKeyword::MinContent => TrackBreadth::MinContent,
+        })
+    }
+}
+
+impl Parse for TrackBreadth<LengthPercentage> {
+    fn parse(context: &ParserContext, input: &mut Parser) -> Result<Self, ParseError> {
+        // FIXME: This and other callers in this file should use
+        // NonNegativeLengthPercentage instead.
+        //
+        // Though it seems these cannot be animated so it's ~ok.
+        if let Ok(lp) = input.try_parse(|i| LengthPercentage::parse_non_negative(context, i)) {
+            return Ok(TrackBreadth::Breadth(lp));
+        }
+
+        if let Ok(f) = input.try_parse(Flex::parse) {
+            return Ok(TrackBreadth::Flex(f));
+        }
+
+        Self::parse_keyword(input)
+    }
+}
+
+impl Parse for TrackSize<LengthPercentage> {
+    fn parse(context: &ParserContext, input: &mut Parser) -> Result<Self, ParseError> {
+        if let Ok(b) = input.try_parse(|i| TrackBreadth::parse(context, i)) {
+            return Ok(TrackSize::Breadth(b));
+        }
+
+        if input
+            .try_parse(|i| i.expect_function_matching("minmax"))
+            .is_ok()
+        {
+            return input.parse_nested_block(|input| {
+                let inflexible_breadth =
+                    match input.try_parse(|i| LengthPercentage::parse_non_negative(context, i)) {
+                        Ok(lp) => TrackBreadth::Breadth(lp),
+                        Err(..) => TrackBreadth::parse_keyword(input)?,
+                    };
+
+                input.expect_comma()?;
+                Ok(TrackSize::Minmax(
+                    inflexible_breadth,
+                    TrackBreadth::parse(context, input)?,
+                ))
+            });
+        }
+
+        input.expect_function_matching("fit-content")?;
+        let lp = input.parse_nested_block(|i| LengthPercentage::parse_non_negative(context, i))?;
+        Ok(TrackSize::FitContent(TrackBreadth::Breadth(lp)))
+    }
+}
+
+impl Parse for ImplicitGridTracks<TrackSize<LengthPercentage>> {
+    fn parse(context: &ParserContext, input: &mut Parser) -> Result<Self, ParseError> {
+        use style_traits::{Separator, Space};
+        let track_sizes = Space::parse(input, |i| TrackSize::parse(context, i))?;
+        if track_sizes.len() == 1 && track_sizes[0].is_initial() {
+            // A single track with the initial value is always represented by an empty slice.
+            return Ok(Default::default());
+        }
+        Ok(ImplicitGridTracks(track_sizes.into()))
+    }
+}
+
+/// Parse the grid line names into a vector of owned strings.
+///
+/// <https://drafts.csswg.org/css-grid/#typedef-line-names>
+pub fn parse_line_names(input: &mut Parser) -> Result<crate::OwnedSlice<CustomIdent>, ParseError> {
+    input.expect_square_bracket_block()?;
+    input.parse_nested_block(|input| {
+        let mut values = vec![];
+        while let Ok(ident) = input.try_parse(|i| CustomIdent::parse(i, &["span", "auto"])) {
+            values.push(ident);
+        }
+
+        Ok(values.into())
+    })
+}
+
+/// The type of `repeat` function (only used in parsing).
+///
+/// <https://drafts.csswg.org/css-grid/#typedef-track-repeat>
+#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq, SpecifiedValueInfo)]
+enum RepeatType {
+    /// [`<auto-repeat>`](https://drafts.csswg.org/css-grid/#typedef-auto-repeat)
+    Auto,
+    /// [`<track-repeat>`](https://drafts.csswg.org/css-grid/#typedef-track-repeat)
+    Normal,
+    /// [`<fixed-repeat>`](https://drafts.csswg.org/css-grid/#typedef-fixed-repeat)
+    Fixed,
+}
+
+impl TrackRepeat<LengthPercentage, Integer> {
+    fn parse_with_repeat_type(
+        context: &ParserContext,
+        input: &mut Parser,
+    ) -> Result<(Self, RepeatType), ParseError> {
+        input
+            .try_parse(|i| i.expect_function_matching("repeat").map_err(|e| e.into()))
+            .and_then(|_| {
+                input.parse_nested_block(|input| {
+                    let count = RepeatCount::parse(context, input)?;
+                    input.expect_comma()?;
+
+                    let is_auto = count == RepeatCount::AutoFit || count == RepeatCount::AutoFill;
+                    let mut repeat_type = if is_auto {
+                        RepeatType::Auto
+                    } else {
+                        // <fixed-size> is a subset of <track-size>, so it should work for both
+                        RepeatType::Fixed
+                    };
+
+                    let mut names = vec![];
+                    let mut values = vec![];
+                    let mut current_names;
+
+                    loop {
+                        current_names = input.try_parse(parse_line_names).unwrap_or_default();
+                        if let Ok(track_size) = input.try_parse(|i| TrackSize::parse(context, i)) {
+                            if !track_size.is_fixed() {
+                                if is_auto {
+                                    // should be <fixed-size> for <auto-repeat>
+                                    return Err(ParseError::custom(
+                                        StyleParseErrorKind::UnspecifiedError,
+                                    ));
+                                }
+
+                                if repeat_type == RepeatType::Fixed {
+                                    repeat_type = RepeatType::Normal // <track-size> for sure
+                                }
+                            }
+
+                            values.push(track_size);
+                            names.push(current_names);
+                            continue;
+                        }
+                        if values.is_empty() {
+                            // expecting at least one <track-size>
+                            return Err(ParseError::custom(StyleParseErrorKind::UnspecifiedError));
+                        }
+                        names.push(current_names); // final `<line-names>`
+                        break; // no more <track-size>, breaking
+                    }
+
+                    let repeat = TrackRepeat {
+                        count,
+                        track_sizes: values.into(),
+                        line_names: names.into(),
+                    };
+
+                    Ok((repeat, repeat_type))
+                })
+            })
+    }
+}
+
+impl Parse for TrackList<LengthPercentage, Integer> {
+    fn parse(context: &ParserContext, input: &mut Parser) -> Result<Self, ParseError> {
+        let mut current_names = vec![];
+        let mut names = vec![];
+        let mut values = vec![];
+
+        // Whether we've parsed an `<auto-repeat>` value.
+        let mut auto_repeat_index = None;
+        // assume that everything is <fixed-size>. This flag is useful when we encounter <auto-repeat>
+        let mut at_least_one_not_fixed = false;
+        loop {
+            current_names
+                .extend_from_slice(&mut input.try_parse(parse_line_names).unwrap_or_default());
+            if let Ok(track_size) = input.try_parse(|i| TrackSize::parse(context, i)) {
+                if !track_size.is_fixed() {
+                    at_least_one_not_fixed = true;
+                    if auto_repeat_index.is_some() {
+                        // <auto-track-list> only accepts <fixed-size> and <fixed-repeat>
+                        return Err(ParseError::custom(StyleParseErrorKind::UnspecifiedError));
+                    }
+                }
+
+                let vec = std::mem::take(&mut current_names);
+                names.push(vec.into());
+                values.push(TrackListValue::TrackSize(track_size));
+                continue;
+            }
+            if let Ok((repeat, type_)) =
+                input.try_parse(|i| TrackRepeat::parse_with_repeat_type(context, i))
+            {
+                match type_ {
+                    RepeatType::Normal => {
+                        at_least_one_not_fixed = true;
+                        if auto_repeat_index.is_some() {
+                            // only <fixed-repeat>
+                            return Err(ParseError::custom(StyleParseErrorKind::UnspecifiedError));
+                        }
+                    },
+                    RepeatType::Auto => {
+                        if auto_repeat_index.is_some() || at_least_one_not_fixed {
+                            // We've either seen <auto-repeat> earlier, or there's at least one non-fixed value
+                            return Err(ParseError::custom(StyleParseErrorKind::UnspecifiedError));
+                        }
+                        auto_repeat_index = Some(values.len());
+                    },
+                    RepeatType::Fixed => {},
+                }
+
+                let vec = std::mem::take(&mut current_names);
+                names.push(vec.into());
+                values.push(TrackListValue::TrackRepeat(repeat));
+                continue;
+            }
+            if values.is_empty() && auto_repeat_index.is_none() {
+                return Err(ParseError::custom(StyleParseErrorKind::UnspecifiedError));
+            }
+            names.push(current_names.into());
+            break;
+        }
+
+        Ok(TrackList {
+            auto_repeat_index: auto_repeat_index.unwrap_or(usize::MAX),
+            values: values.into(),
+            line_names: names.into(),
+        })
+    }
+}
+
+#[inline]
+fn allow_grid_template_subgrids() -> bool {
+    crate::pref!("layout.css.grid-template-subgrid-value.enabled", gecko = true)
+}
+
+#[inline]
+fn allow_grid_template_masonry() -> bool {
+    crate::pref!("layout.css.grid-template-masonry-value.enabled")
+}
+
+impl Parse for GridTemplateComponent<LengthPercentage, Integer> {
+    fn parse(context: &ParserContext, input: &mut Parser) -> Result<Self, ParseError> {
+        if input.try_parse(|i| i.expect_ident_matching("none")).is_ok() {
+            return Ok(GridTemplateComponent::None);
+        }
+
+        Self::parse_without_none(context, input)
+    }
+}
+
+impl GridTemplateComponent<LengthPercentage, Integer> {
+    /// Parses a `GridTemplateComponent<LengthPercentage>` except `none` keyword.
+    pub fn parse_without_none(
+        context: &ParserContext,
+        input: &mut Parser,
+    ) -> Result<Self, ParseError> {
+        if allow_grid_template_subgrids() {
+            if let Ok(t) = input.try_parse(|i| LineNameList::parse(context, i)) {
+                return Ok(GridTemplateComponent::Subgrid(Box::new(t)));
+            }
+        }
+        if allow_grid_template_masonry()
+            && input
+                .try_parse(|i| i.expect_ident_matching("masonry"))
+                .is_ok()
+        {
+            return Ok(GridTemplateComponent::Masonry);
+        }
+        let track_list = TrackList::parse(context, input)?;
+        Ok(GridTemplateComponent::TrackList(Box::new(track_list)))
+    }
+}
+
+impl Parse for NameRepeat<Integer> {
+    fn parse(context: &ParserContext, input: &mut Parser) -> Result<Self, ParseError> {
+        input.expect_function_matching("repeat")?;
+        input.parse_nested_block(|i| {
+            let count = RepeatCount::parse(context, i)?;
+
+            // TODO(Bug 2037744) - Enable calc()-expressions that can only be resolved at
+            // computed value time (due to relative lengths, sibling-index(), etc.).
+            if matches!(count, RepeatCount::Number(ref n) if n.resolve().is_none()) {
+                return Err(ParseError::custom(StyleParseErrorKind::UnspecifiedError));
+            }
+
+            // NameRepeat doesn't accept `auto-fit`
+            // https://drafts.csswg.org/css-grid/#typedef-name-repeat
+            if matches!(count, RepeatCount::AutoFit) {
+                return Err(ParseError::custom(StyleParseErrorKind::UnspecifiedError));
+            }
+
+            i.expect_comma()?;
+            let mut names_list = vec![];
+            names_list.push(parse_line_names(i)?); // there should be at least one
+            while let Ok(names) = i.try_parse(parse_line_names) {
+                names_list.push(names);
+            }
+
+            Ok(NameRepeat {
+                count,
+                line_names: names_list.into(),
+            })
+        })
+    }
+}
+
+impl Parse for LineNameListValue<Integer> {
+    fn parse(context: &ParserContext, input: &mut Parser) -> Result<Self, ParseError> {
+        if let Ok(repeat) = input.try_parse(|i| NameRepeat::parse(context, i)) {
+            return Ok(LineNameListValue::Repeat(repeat));
+        }
+
+        parse_line_names(input).map(LineNameListValue::LineNames)
+    }
+}
+
+impl LineNameListValue<Integer> {
+    /// Returns the length of `<line-names>` after expanding repeat(N, ...). This returns zero for
+    /// repeat(auto-fill, ...).
+    #[inline]
+    pub fn line_names_length(&self) -> usize {
+        match *self {
+            Self::LineNames(..) => 1,
+            Self::Repeat(ref r) => {
+                match r.count {
+                    // Note: RepeatCount is always >= 1. Unresolvable calc
+                    // expressions were rejected at parse-time.
+                    RepeatCount::Number(ref v) => {
+                        r.line_names.len() * v.resolve().unwrap() as usize
+                    },
+                    _ => 0,
+                }
+            },
+        }
+    }
+}
+
+impl Parse for LineNameList<Integer> {
+    fn parse(context: &ParserContext, input: &mut Parser) -> Result<Self, ParseError> {
+        input.expect_ident_matching("subgrid")?;
+
+        let mut auto_repeat = false;
+        let mut expanded_line_names_length = 0;
+        let mut line_names = vec![];
+        while let Ok(value) = input.try_parse(|i| LineNameListValue::parse(context, i)) {
+            match value {
+                LineNameListValue::Repeat(ref r) if r.is_auto_fill() => {
+                    if auto_repeat {
+                        // On a subgridded axis, the auto-fill keyword is only valid once per
+                        // <line-name-list>.
+                        // https://drafts.csswg.org/css-grid/#auto-repeat
+                        return Err(ParseError::custom(StyleParseErrorKind::UnspecifiedError));
+                    }
+                    auto_repeat = true;
+                },
+                _ => (),
+            };
+
+            expanded_line_names_length += value.line_names_length();
+            line_names.push(value);
+        }
+
+        Ok(LineNameList {
+            expanded_line_names_length,
+            line_names: line_names.into(),
+        })
+    }
+}