Enable high-fidelity SVG export for text-on-path

Author: jsjgdh

node-graph/libraries/graphic-types/src/lib.rs

@@ -77,6 +77,7 @@ pub mod migrations {
 					segment_domain: old.segment_domain,
 					region_domain: old.region_domain,
 					upstream_data: old.upstream_graphic_group,
+					text_on_path_metadata: None,
 				});
 				*vector_table.iter_mut().next().unwrap().transform = old.transform;
 				*vector_table.iter_mut().next().unwrap().alpha_blending = old.alpha_blending;

node-graph/libraries/rendering/src/renderer.rs

@@ -787,6 +787,27 @@ impl Render for Table<Graphic> {
 impl Render for Table<Vector> {
 	fn render_svg(&self, render: &mut SvgRender, render_params: &RenderParams) {
 		for row in self.iter() {
+			if render_params.for_export {
+				if let Some(ref meta) = row.element.text_on_path_metadata {
+					let path_id = format!("textpath-{}", generate_uuid());
+					write!(&mut render.svg_defs, r#"<path id="{path_id}" d="{}" fill="none"/>"#, meta.path_d).unwrap();
+
+					let font_style_css = format!("font-family: {}; font-size: {}px; font-style: {};", meta.font_family, meta.font_size, meta.font_style);
+					let start_offset_attr = if meta.start_offset_percent { format!("{}%", meta.start_offset * 100.0) } else { format!("{}", meta.start_offset) };
+					let matrix = format_transform_matrix(*row.transform);
+					let transform_attr = if matrix.is_empty() { String::new() } else { format!(r#" transform="{matrix}""#) };
+					let text_length_attr = meta.text_length.map(|tl| format!(r#" textLength="{tl}" lengthAdjust="{}""#, meta.length_adjust)).unwrap_or_default();
+					let side_attr = if meta.side == "right" { r#" side="right""# } else { "" };
+					let anchor_style = format!("text-anchor: {};", meta.text_anchor);
+					let method = &meta.method;
+					let spacing = &meta.spacing;
+					let text = &meta.text;
+
+					render.leaf_node(format!(r##"<text style="{font_style_css} {anchor_style}"{transform_attr}><textPath href="#{path_id}" startOffset="{start_offset_attr}" method="{method}" spacing="{spacing}"{side_attr}{text_length_attr}>{text}</textPath></text>"##));
+					continue;
+				}
+			}
+
 			let multiplied_transform = *row.transform;
 			let vector = &row.element;
 			// Only consider strokes with non-zero weight, since default strokes with zero weight would prevent assigning the correct stroke transform

node-graph/libraries/vector-types/src/lib.rs

@@ -13,6 +13,7 @@ pub use math::{QuadExt, RectExt};
 pub use subpath::Subpath;
 pub use vector::Vector;
 pub use vector::reference_point::ReferencePoint;
+pub use vector::TextOnPathMetadata;
 
 // Re-export dependencies that users of this crate will need
 pub use dyn_any;

node-graph/libraries/vector-types/src/vector/vector_types.rs

@@ -14,6 +14,33 @@ use dyn_any::StaticType;
 use glam::{DAffine2, DVec2};
 use kurbo::{Affine, BezPath, Rect, Shape};
 use std::collections::HashMap;
+use std::sync::Arc;
+
+/// Metadata carried by a text-on-path `Vector` to enable lossless SVG `<textPath>` export.
+/// When present on the first row of a `Table<Vector>`, the SVG renderer emits
+/// `<text><textPath href="...">` instead of raw `<path>` outlines.
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct TextOnPathMetadata {
+	pub text: String,
+	pub font_family: String,
+	pub font_style: String,
+	pub font_size: f64,
+	/// SVG path `d` attribute string for the reference path.
+	pub path_d: String,
+	pub start_offset: f64,
+	pub start_offset_percent: bool,
+	/// "start" | "middle" | "end"
+	pub text_anchor: String,
+	/// "left" | "right"
+	pub side: String,
+	/// "align" | "stretch"
+	pub method: String,
+	/// "exact" | "auto"
+	pub spacing: String,
+	pub text_length: Option<f64>,
+	/// "spacing" | "spacingAndGlyphs"
+	pub length_adjust: String,
+}
 
 /// Represents vector graphics data, composed of Bézier curves in a path or mesh arrangement.
 ///
@@ -36,6 +63,11 @@ pub struct Vector<Upstream> {
 	/// Without this, the tools would be working with a collapsed version of the data which has no reference to the original child layers that were booleaned together, resulting in the inner layers not being editable.
 	#[serde(alias = "upstream_group")]
 	pub upstream_data: Upstream,
+
+	/// When set, this vector was produced by a text-on-path node. SVG export uses this metadata
+	/// to emit a `<text><textPath>` element instead of raw path outlines.
+	#[serde(default, skip_serializing_if = "Option::is_none")]
+	pub text_on_path_metadata: Option<Arc<TextOnPathMetadata>>,
 }
 unsafe impl<Upstream: 'static> StaticType for Vector<Upstream> {
 	type Static = Self;
@@ -50,6 +82,7 @@ impl<Upstream: Default + 'static> Default for Vector<Upstream> {
 			segment_domain: SegmentDomain::new(),
 			region_domain: RegionDomain::new(),
 			upstream_data: Upstream::default(),
+			text_on_path_metadata: None,
 		}
 	}
 }
@@ -61,7 +94,7 @@ impl<Upstream> std::hash::Hash for Vector<Upstream> {
 		self.region_domain.hash(state);
 		self.style.hash(state);
 		self.colinear_manipulators.hash(state);
-		// We don't hash the upstream_data intentionally
+		// We don't hash upstream_data or text_on_path_metadata intentionally
 	}
 }
 

node-graph/nodes/vector/src/vector_nodes.rs

@@ -1343,6 +1343,7 @@ async fn sample_polyline(
 				colinear_manipulators: Default::default(),
 				style: std::mem::take(&mut row.element.style),
 				upstream_data: std::mem::take(&mut row.element.upstream_data),
+				..Default::default()
 			};
 			// Transfer the stroke transform from the input vector content to the result.
 			result.style.set_stroke_transform(row.transform);