Migrate fonts to be stored as resources (#4165)

* Good start

* Impl

* allow responses.add(async { Message::NoOp });

* Fix

* Cache font blob in text node

* Refactor font handling to use Font struct direcly

* Fix fmt

* Embedd Font Resources by default

* Review

* Review

* Cache font info based on ResourceHash

node-graph/nodes/text/Cargo.toml

@@ -15,6 +15,7 @@ wasm = ["core-types/wasm", "tsify", "wasm-bindgen"]
 # Local dependencies
 core-types = { workspace = true }
 graphene-hash = { workspace = true }
+graphene-resource = { workspace = true }
 raster-types = { workspace = true }
 vector-types = { workspace = true }
 node-macro = { workspace = true }

node-graph/nodes/text/src/font.rs

@@ -0,0 +1,71 @@
+use core_types::graphene_hash::CacheHash;
+use dyn_any::DynAny;
+
+/// A font type (storing font family and font style)
+#[cfg_attr(feature = "wasm", derive(tsify::Tsify))]
+#[derive(Debug, Clone, Eq, DynAny)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct Font {
+	#[cfg_attr(feature = "serde", serde(rename = "fontFamily"))]
+	pub font_family: String,
+	#[cfg_attr(feature = "serde", serde(rename = "fontStyle", deserialize_with = "migrate_font_style"))]
+	pub font_style: String,
+}
+
+impl std::hash::Hash for Font {
+	fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+		self.font_family.hash(state);
+		self.font_style.hash(state);
+	}
+}
+
+impl CacheHash for Font {
+	fn cache_hash<H: core::hash::Hasher>(&self, state: &mut H) {
+		self.font_family.cache_hash(state);
+		self.font_style.cache_hash(state);
+	}
+}
+
+impl PartialEq for Font {
+	fn eq(&self, other: &Self) -> bool {
+		self.font_family == other.font_family && self.font_style == other.font_style
+	}
+}
+
+impl Font {
+	pub fn new(font_family: String, font_style: String) -> Self {
+		Self { font_family, font_style }
+	}
+
+	pub fn new_with_default_style(font_family: String) -> Self {
+		Self::new(font_family, core_types::consts::DEFAULT_FONT_STYLE.into())
+	}
+
+	pub fn named_weight(weight: u32) -> &'static str {
+		// From https://developer.mozilla.org/en-US/docs/Web/CSS/font-weight#common_weight_name_mapping
+		match weight {
+			100 => "Thin",
+			200 => "Extra Light",
+			300 => "Light",
+			400 => "Regular",
+			500 => "Medium",
+			600 => "Semi Bold",
+			700 => "Bold",
+			800 => "Extra Bold",
+			900 => "Black",
+			950 => "Extra Black",
+			_ => "Regular",
+		}
+	}
+}
+impl Default for Font {
+	fn default() -> Self {
+		Self::new(core_types::consts::DEFAULT_FONT_FAMILY.into(), core_types::consts::DEFAULT_FONT_STYLE.into())
+	}
+}
+
+// TODO: Eventually remove this migration document upgrade code
+fn migrate_font_style<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<String, D::Error> {
+	use serde::Deserialize;
+	String::deserialize(deserializer).map(|name| if name == "Normal (400)" { "Regular (400)".to_string() } else { name })
+}

node-graph/nodes/text/src/font_cache.rs

@@ -1,142 +0,0 @@
-use core_types::graphene_hash::CacheHash;
-use dyn_any::DynAny;
-use parley::fontique::Blob;
-use std::collections::HashMap;
-use std::sync::Arc;
-
-/// A font type (storing font family and font style and an optional preview URL)
-#[cfg_attr(feature = "wasm", derive(tsify::Tsify))]
-#[derive(Debug, Clone, Eq, DynAny)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-pub struct Font {
-	#[cfg_attr(feature = "serde", serde(rename = "fontFamily"))]
-	pub font_family: String,
-	#[cfg_attr(feature = "serde", serde(rename = "fontStyle", deserialize_with = "migrate_font_style"))]
-	pub font_style: String,
-	#[cfg_attr(feature = "serde", serde(skip))]
-	pub font_style_to_restore: Option<String>,
-}
-
-impl std::hash::Hash for Font {
-	fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-		self.font_family.hash(state);
-		self.font_style.hash(state);
-		// Don't consider `font_style_to_restore` in the HashMaps
-	}
-}
-
-impl CacheHash for Font {
-	fn cache_hash<H: core::hash::Hasher>(&self, state: &mut H) {
-		self.font_family.cache_hash(state);
-		self.font_style.cache_hash(state);
-		// Don't consider `font_style_to_restore` in the HashMaps
-	}
-}
-
-impl PartialEq for Font {
-	fn eq(&self, other: &Self) -> bool {
-		// Don't consider `font_style_to_restore` in the HashMaps
-		self.font_family == other.font_family && self.font_style == other.font_style
-	}
-}
-
-impl Font {
-	pub fn new(font_family: String, font_style: String) -> Self {
-		Self {
-			font_family,
-			font_style,
-			font_style_to_restore: None,
-		}
-	}
-
-	pub fn named_weight(weight: u32) -> &'static str {
-		// From https://developer.mozilla.org/en-US/docs/Web/CSS/font-weight#common_weight_name_mapping
-		match weight {
-			100 => "Thin",
-			200 => "Extra Light",
-			300 => "Light",
-			400 => "Regular",
-			500 => "Medium",
-			600 => "Semi Bold",
-			700 => "Bold",
-			800 => "Extra Bold",
-			900 => "Black",
-			950 => "Extra Black",
-			_ => "Regular",
-		}
-	}
-}
-impl Default for Font {
-	fn default() -> Self {
-		Self::new(core_types::consts::DEFAULT_FONT_FAMILY.into(), core_types::consts::DEFAULT_FONT_STYLE.into())
-	}
-}
-
-/// A cache of all loaded font data and preview urls along with the default font (send from `init_app` in `editor_api.rs`)
-#[derive(Clone, Default, DynAny)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-pub struct FontCache {
-	/// Actual font file data used for rendering a font
-	font_file_data: HashMap<Font, Vec<u8>>,
-}
-
-impl std::fmt::Debug for FontCache {
-	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-		f.debug_struct("FontCache").field("font_file_data", &self.font_file_data.keys().collect::<Vec<_>>()).finish()
-	}
-}
-
-impl std::hash::Hash for FontCache {
-	fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-		self.font_file_data.len().hash(state);
-		self.font_file_data.keys().for_each(|font| font.hash(state));
-	}
-}
-
-impl PartialEq for FontCache {
-	fn eq(&self, other: &Self) -> bool {
-		if self.font_file_data.len() != other.font_file_data.len() {
-			return false;
-		}
-		self.font_file_data.keys().all(|font| other.font_file_data.contains_key(font))
-	}
-}
-
-impl FontCache {
-	/// Returns the font family name if the font is cached, otherwise returns the fallback font family name if that is cached
-	pub fn resolve_font<'a>(&'a self, font: &'a Font) -> Option<&'a Font> {
-		if self.font_file_data.contains_key(font) {
-			Some(font)
-		} else {
-			self.font_file_data
-				.keys()
-				.find(|font| font.font_family == core_types::consts::DEFAULT_FONT_FAMILY && font.font_style == core_types::consts::DEFAULT_FONT_STYLE)
-		}
-	}
-
-	/// Try to get the bytes for a font
-	pub fn get<'a>(&'a self, font: &'a Font) -> Option<(&'a Vec<u8>, &'a Font)> {
-		self.resolve_font(font).and_then(|font| self.font_file_data.get(font).map(|data| (data, font)))
-	}
-
-	/// Get font data as a Blob for use with parley/skrifa
-	pub fn get_blob<'a>(&'a self, font: &'a Font) -> Option<(Blob<u8>, &'a Font)> {
-		self.get(font).map(|(data, font)| (Blob::new(Arc::new(data.clone())), font))
-	}
-
-	/// Check if the font is already loaded
-	pub fn loaded_font(&self, font: &Font) -> bool {
-		self.font_file_data.contains_key(font)
-	}
-
-	/// Insert a new font into the cache
-	pub fn insert(&mut self, font: Font, data: Vec<u8>) {
-		self.font_file_data.insert(font.clone(), data);
-	}
-}
-
-// TODO: Eventually remove this migration document upgrade code
-fn migrate_font_style<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<String, D::Error> {
-	use serde::Deserialize;
-	String::deserialize(deserializer).map(|name| if name == "Normal (400)" { "Regular (400)".to_string() } else { name })
-}

node-graph/nodes/text/src/lib.rs

@@ -1,4 +1,4 @@
-mod font_cache;
+mod font;
 pub mod json;
 mod path_builder;
 pub mod regex;
@@ -16,7 +16,7 @@ use unicode_segmentation::UnicodeSegmentation;
 
 // Re-export for convenience
 pub use core_types as gcore;
-pub use font_cache::*;
+pub use font::*;
 pub use text_context::TextContext;
 pub use to_path::*;
 pub use vector_types;

node-graph/nodes/text/src/text_context.rs

@@ -1,7 +1,8 @@
-use super::{Font, FontCache, TypesettingConfig};
+use super::TypesettingConfig;
 use core::cell::RefCell;
 use core_types::list::List;
 use glam::DVec2;
+use graphene_resource::{Resource, ResourceHash};
 use parley::fontique::{Blob, FamilyId, FontInfo};
 use parley::{AlignmentOptions, FontContext, Layout, LayoutContext, LineHeight, PositionedLayoutItem, StyleProperty};
 use std::collections::HashMap;
@@ -19,8 +20,7 @@ thread_local! {
 pub struct TextContext {
 	font_context: FontContext,
 	layout_context: LayoutContext<()>,
-	/// Cached font metadata for performance optimization
-	font_info_cache: HashMap<Font, (FamilyId, FontInfo)>,
+	font_info_cache: HashMap<ResourceHash, (FamilyId, FontInfo)>,
 }
 
 impl TextContext {
@@ -32,40 +32,30 @@ impl TextContext {
 		THREAD_TEXT.with_borrow_mut(f)
 	}
 
-	/// Resolve a font and return its data as a Blob if available
-	fn resolve_font_data<'a>(&self, font: &'a Font, font_cache: &'a FontCache) -> Option<(Blob<u8>, &'a Font)> {
-		font_cache.get_blob(font)
-	}
-
-	/// Get or cache font information for a given font
-	fn get_font_info(&mut self, font: &Font, font_data: &Blob<u8>) -> Option<(String, FontInfo)> {
-		// Check if we already have the font info cached
-		if let Some((family_id, font_info)) = self.font_info_cache.get(font)
+	/// Get or cache font information for the given font resource.
+	fn get_font_info(&mut self, font: &Resource) -> Option<(String, FontInfo)> {
+		let hash = font.hash();
+		if let Some((family_id, font_info)) = self.font_info_cache.get(&hash)
 			&& let Some(family_name) = self.font_context.collection.family_name(*family_id)
 		{
 			return Some((family_name.to_string(), font_info.clone()));
 		}
 
-		// Register the font and cache the info
-		let families = self.font_context.collection.register_fonts(font_data.clone(), None);
+		let families = self.font_context.collection.register_fonts(Blob::new(font.into()), None);
 
 		families.first().and_then(|(family_id, fonts_info)| {
 			fonts_info.first().and_then(|font_info| {
 				self.font_context.collection.family_name(*family_id).map(|family_name| {
-					// Cache the font info for future use
-					self.font_info_cache.insert(font.clone(), (*family_id, font_info.clone()));
+					self.font_info_cache.insert(hash, (*family_id, font_info.clone()));
 					(family_name.to_string(), font_info.clone())
 				})
 			})
 		})
 	}
 
-	/// Create a text layout using the specified font and typesetting configuration
-	fn layout_text(&mut self, text: &str, font: &Font, font_cache: &FontCache, typesetting: TypesettingConfig) -> Option<Layout<()>> {
-		// Note that the actual_font may not be the desired font if that font is not yet loaded.
-		// It is important not to cache the default font under the name of another font.
-		let (font_data, actual_font) = self.resolve_font_data(font, font_cache)?;
-		let (font_family, font_info) = self.get_font_info(actual_font, &font_data)?;
+	/// Create a text layout from the given font resource and typesetting configuration.
+	fn layout_text(&mut self, text: &str, font: &Resource, typesetting: TypesettingConfig) -> Option<Layout<()>> {
+		let (font_family, font_info) = self.get_font_info(font)?;
 
 		const DISPLAY_SCALE: f32 = 1.;
 		let mut builder = self.layout_context.ranged_builder(&mut self.font_context, text, DISPLAY_SCALE, false);
@@ -89,8 +79,8 @@ impl TextContext {
 	}
 
 	/// Convert text to vector paths using the specified font and typesetting configuration
-	pub fn to_path(&mut self, text: &str, font: &Font, font_cache: &FontCache, typesetting: TypesettingConfig, per_glyph_items: bool) -> List<Vector> {
-		let Some(layout) = self.layout_text(text, font, font_cache, typesetting) else {
+	pub fn to_path(&mut self, text: &str, font: &Resource, typesetting: TypesettingConfig, per_glyph_items: bool) -> List<Vector> {
+		let Some(layout) = self.layout_text(text, font, typesetting) else {
 			return List::new_from_element(Vector::default());
 		};
 
@@ -162,8 +152,8 @@ impl TextContext {
 	}
 
 	/// Calculate the bounding box of text using the specified font and typesetting configuration
-	pub fn bounding_box(&mut self, text: &str, font: &Font, font_cache: &FontCache, typesetting: TypesettingConfig, for_clipping_test: bool) -> DVec2 {
-		let Some(layout) = self.layout_text(text, font, font_cache, typesetting) else {
+	pub fn bounding_box(&mut self, text: &str, font: &Resource, typesetting: TypesettingConfig, for_clipping_test: bool) -> DVec2 {
+		let Some(layout) = self.layout_text(text, font, typesetting) else {
 			return DVec2::ZERO;
 		};
 
@@ -181,9 +171,9 @@ impl TextContext {
 	}
 
 	/// Check if text lines are being clipped due to height constraints
-	pub fn lines_clipping(&mut self, text: &str, font: &Font, font_cache: &FontCache, typesetting: TypesettingConfig) -> bool {
+	pub fn lines_clipping(&mut self, text: &str, font: &Resource, typesetting: TypesettingConfig) -> bool {
 		let Some(max_height) = typesetting.max_height else { return false };
-		let bounds = self.bounding_box(text, font, font_cache, typesetting, true);
+		let bounds = self.bounding_box(text, font, typesetting, true);
 		max_height < bounds.y
 	}
 }

node-graph/nodes/text/src/to_path.rs

@@ -1,23 +1,18 @@
+use super::TypesettingConfig;
 use super::text_context::TextContext;
-use super::{Font, FontCache, TypesettingConfig};
 use core_types::list::List;
 use glam::DVec2;
-use parley::fontique::Blob;
-use std::sync::Arc;
+use graphene_resource::Resource;
 use vector_types::Vector;
 
-pub fn to_path(text: &str, font: &Font, font_cache: &FontCache, typesetting: TypesettingConfig, per_glyph_items: bool) -> List<Vector> {
-	TextContext::with_thread_local(|ctx| ctx.to_path(text, font, font_cache, typesetting, per_glyph_items))
+pub fn to_path(text: &str, font: &Resource, typesetting: TypesettingConfig, per_glyph_items: bool) -> List<Vector> {
+	TextContext::with_thread_local(|ctx| ctx.to_path(text, font, typesetting, per_glyph_items))
 }
 
-pub fn bounding_box(text: &str, font: &Font, font_cache: &FontCache, typesetting: TypesettingConfig, for_clipping_test: bool) -> DVec2 {
-	TextContext::with_thread_local(|ctx| ctx.bounding_box(text, font, font_cache, typesetting, for_clipping_test))
+pub fn bounding_box(text: &str, font: &Resource, typesetting: TypesettingConfig, for_clipping_test: bool) -> DVec2 {
+	TextContext::with_thread_local(|ctx| ctx.bounding_box(text, font, typesetting, for_clipping_test))
 }
 
-pub fn load_font(data: &[u8]) -> Blob<u8> {
-	Blob::new(Arc::new(data.to_vec()))
-}
-
-pub fn lines_clipping(text: &str, font: &Font, font_cache: &FontCache, typesetting: TypesettingConfig) -> bool {
-	TextContext::with_thread_local(|ctx| ctx.lines_clipping(text, font, font_cache, typesetting))
+pub fn lines_clipping(text: &str, font: &Resource, typesetting: TypesettingConfig) -> bool {
+	TextContext::with_thread_local(|ctx| ctx.lines_clipping(text, font, typesetting))
 }