blitz-pdf 0.1.6 → 0.1.7

package/vendor/fontique/src/family.rs

@@ -0,0 +1,111 @@
+// Copyright 2024 the Parley Authors
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+//! Model for font families.
+
+use super::{FontStyle, FontWeight, FontWidth, family_name::FamilyName, font::FontInfo};
+use crate::AtomicCounter;
+use alloc::sync::Arc;
+use core::sync::atomic::Ordering;
+use smallvec::SmallVec;
+
+/// Unique identifier for a font family.
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
+#[repr(transparent)]
+pub struct FamilyId(u64);
+
+impl FamilyId {
+    /// Creates a new unique identifier.
+    #[allow(clippy::new_without_default)]
+    pub fn new() -> Self {
+        /// Make sure this is larger than the largest generic family id.
+        static ID_COUNTER: AtomicCounter = AtomicCounter::new(64);
+        #[allow(clippy::useless_conversion, reason = "Not useless on 32-bit platforms")]
+        Self(ID_COUNTER.fetch_add(1, Ordering::Relaxed).into())
+    }
+
+    /// Returns the underlying integer value.
+    pub fn to_u64(self) -> u64 {
+        self.0
+    }
+}
+
+/// Named set of fonts that are instances of a core design.
+#[derive(Clone, Debug)]
+pub struct FamilyInfo(Arc<FamilyInner>);
+
+impl FamilyInfo {
+    /// Creates a new font family object with the given name and collection of
+    /// fonts.
+    pub fn new(name: FamilyName, fonts: impl IntoIterator<Item = FontInfo>) -> Self {
+        let fonts: SmallVec<[FontInfo; 4]> = fonts.into_iter().collect();
+        let default_font = super::matching::match_font(
+            &fonts[..],
+            FontWidth::default(),
+            FontStyle::default(),
+            FontWeight::default(),
+            false,
+        )
+        .unwrap_or(0);
+        Self(Arc::new(FamilyInner {
+            name,
+            default_font,
+            fonts,
+        }))
+    }
+
+    /// Returns the unique identifier for the family.
+    pub fn id(&self) -> FamilyId {
+        self.0.name.id()
+    }
+
+    /// Returns the name of the family.
+    pub fn name(&self) -> &str {
+        self.0.name.name()
+    }
+
+    /// Returns the collection of fonts that are members of the family.
+    pub fn fonts(&self) -> &[FontInfo] {
+        &self.0.fonts
+    }
+
+    /// Returns index of the default font of the family.
+    pub fn default_font_index(&self) -> usize {
+        self.0.default_font
+    }
+
+    /// Returns the default font of the family.
+    pub fn default_font(&self) -> Option<&FontInfo> {
+        self.0.fonts.get(self.0.default_font)
+    }
+
+    /// Returns the index of the best font from the family for the given attributes.
+    pub fn match_index(
+        &self,
+        width: FontWidth,
+        style: FontStyle,
+        weight: FontWeight,
+        synthesize_style: bool,
+    ) -> Option<usize> {
+        super::matching::match_font(self.fonts(), width, style, weight, synthesize_style)
+    }
+
+    /// Selects the best font from the family for the given attributes.
+    pub fn match_font(
+        &self,
+        width: FontWidth,
+        style: FontStyle,
+        weight: FontWeight,
+        synthesize_style: bool,
+    ) -> Option<&FontInfo> {
+        self.fonts()
+            .get(self.match_index(width, style, weight, synthesize_style)?)
+    }
+}
+
+#[derive(Clone, Debug)]
+struct FamilyInner {
+    pub(crate) name: FamilyName,
+    default_font: usize,
+    fonts: SmallVec<[FontInfo; 4]>,
+}

package/vendor/fontique/src/family_name.rs

@@ -0,0 +1,153 @@
+// Copyright 2024 the Parley Authors
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+//! Model for font family names.
+
+use super::family::FamilyId;
+use alloc::sync::Arc;
+use hashbrown::HashMap;
+use smallvec::SmallVec;
+
+/// Handle for a font family that includes both the name and a unique
+/// identifier.
+#[derive(Clone, Debug)]
+pub struct FamilyName {
+    id: FamilyId,
+    name: Arc<str>,
+}
+
+impl FamilyName {
+    /// Returns the unique identifier for the font family.
+    pub fn id(&self) -> FamilyId {
+        self.id
+    }
+
+    /// Returns the name of the font family.
+    pub fn name(&self) -> &str {
+        &self.name
+    }
+}
+
+impl From<&FamilyName> for FamilyId {
+    fn from(value: &FamilyName) -> Self {
+        value.id
+    }
+}
+
+/// Bidirectional map that associates font family names with unique
+/// identifiers.
+#[derive(Clone, Default)]
+pub struct FamilyNameMap {
+    name_map: HashMap<Arc<[u8]>, FamilyName>,
+    id_map: HashMap<FamilyId, FamilyName>,
+}
+
+impl FamilyNameMap {
+    /// Returns the family name object for the given name.
+    pub fn get(&self, name: &str) -> Option<&FamilyName> {
+        let key = NameKey::from_str(name);
+        self.name_map.get(key.as_bytes())
+    }
+
+    /// Returns the family name object for the given identifier.
+    pub fn get_by_id(&self, id: FamilyId) -> Option<&FamilyName> {
+        self.id_map.get(&id)
+    }
+
+    /// Returns the family name object with the given name or creates
+    /// a new one if it doesn't exist.
+    pub fn get_or_insert(&mut self, name: &str) -> FamilyName {
+        let key = NameKey::from_str(name);
+        if let Some(name) = self.name_map.get(key.as_bytes()) {
+            name.clone()
+        } else {
+            let new_name = FamilyName {
+                name: name.into(),
+                id: FamilyId::new(),
+            };
+            self.name_map
+                .insert(key.as_bytes().into(), new_name.clone());
+            self.id_map.insert(new_name.id, new_name.clone());
+            new_name
+        }
+    }
+
+    /// Adds `name` as an alias for the given family identifier.
+    #[allow(unused)]
+    pub fn add_alias(&mut self, id: FamilyId, name: &str) {
+        if self.id_map.contains_key(&id) {
+            let key = NameKey::from_str(name);
+            if self.name_map.contains_key(key.as_bytes()) {
+                return;
+            }
+            let new_name = FamilyName {
+                name: name.into(),
+                id,
+            };
+            self.name_map.insert(key.as_bytes().into(), new_name);
+        }
+    }
+
+    /// Returns an iterator over all of the font family names, including aliases.
+    pub fn iter(&self) -> impl Iterator<Item = &FamilyName> + Clone {
+        self.name_map.values()
+    }
+
+    /// Returns an iterator over all of the font family identifiers.
+    pub fn ids(&self) -> impl Iterator<Item = FamilyId> + Clone + '_ {
+        self.id_map.keys().copied()
+    }
+}
+
+/// Key for case-insensitive lookup of family names.
+#[derive(Default)]
+struct NameKey {
+    data: SmallVec<[u8; 128]>,
+}
+
+impl NameKey {
+    fn from_str(s: &str) -> Self {
+        let mut res = Self::default();
+        let mut buf = [0_u8; 4];
+        for ch in s.chars() {
+            for ch in ch.to_lowercase() {
+                res.data
+                    .extend_from_slice(ch.encode_utf8(&mut buf).as_bytes());
+            }
+        }
+        res
+    }
+
+    pub fn as_bytes(&self) -> &[u8] {
+        &self.data
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::FamilyNameMap;
+    use alloc::vec;
+    use alloc::vec::Vec;
+
+    #[test]
+    fn iterate_names_and_ids() {
+        let mut map = FamilyNameMap::default();
+        let name = map.get_or_insert("Family");
+        map.add_alias(name.id(), "Alias");
+        let other_name = map.get_or_insert("Other family");
+
+        let mut names: Vec<_> = map.iter().map(|f| f.name()).collect();
+        names.sort_unstable();
+        assert_eq!(
+            names,
+            &["Alias", "Family", "Other family"],
+            "family names and aliases should both show up"
+        );
+
+        let mut ids: Vec<_> = map.ids().collect();
+        ids.sort_unstable();
+        let mut expected = vec![name.id(), other_name.id()];
+        expected.sort_unstable();
+        assert_eq!(ids, expected, "family identifiers should only show up once");
+    }
+}