SVG textPath compliance: enums, rendering logic, SVG export elements, and XML import pre-parse

Author: jsjgdh

editor/src/messages/portfolio/document/graph_operation/graph_operation_message_handler.rs

@@ -430,6 +430,9 @@ impl MessageHandler<GraphOperationMessage, GraphOperationMessageContext<'_>> for
 
 				let graphite_gradient_stops = extract_graphite_gradient_stops(&svg);
 
+				// Pre-parse the raw SVG XML for <textPath> attributes that usvg doesn't expose
+				let textpath_attrs = pre_parse_textpath_attrs(&svg);
+
 				// Pass identity so each leaf layer receives only its SVG-native transform from `abs_transform`.
 				// The placement offset is then applied once to the root group layer below.
 				import_usvg_node(
@@ -439,6 +442,7 @@ impl MessageHandler<GraphOperationMessage, GraphOperationMessageContext<'_>> for
 					parent,
 					insert_index,
 					&graphite_gradient_stops,
+					&textpath_attrs,
 				);
 
 				// After import, `layer_node` is set to the root group. Apply the placement transform to it
@@ -538,6 +542,76 @@ fn parse_hex_stop_color(hex: &str, opacity: f32) -> Option<Color> {
 	Some(Color::from_rgbaf32_unchecked(r, g, b, opacity))
 }
 
+/// Attributes from `<textPath>` elements that `usvg` does not expose.
+/// Keyed by the parent `<text>` element's `id` attribute (may be empty string if no id).
+/// For simple SVGs with one `<text>` element, the key will be "".
+#[derive(Debug, Default, Clone)]
+struct TextPathAttrs {
+	/// SVG `method` attribute: "align" (default) | "stretch"
+	pub method: Option<String>,
+	/// SVG `spacing` attribute: "exact" (default) | "auto"
+	pub spacing: Option<String>,
+	/// SVG `side` attribute: "left" (default) | "right"
+	pub side: Option<String>,
+	/// SVG `textLength` attribute in user units
+	pub text_length: Option<f64>,
+	/// SVG `lengthAdjust` attribute: "spacing" | "spacingAndGlyphs"
+	pub length_adjust: Option<String>,
+}
+
+/// Scan the raw SVG string for `<textPath>` elements and extract the attributes that
+/// `usvg` does not expose. Returns a map from parent `<text>` id → attrs.
+/// Uses simple byte-level scanning instead of a full XML parser to avoid new dependencies.
+fn pre_parse_textpath_attrs(svg: &str) -> std::collections::HashMap<String, TextPathAttrs> {
+	/// Extract the value of `attr="..."` or `attr='...'` from a raw attribute string.
+	fn get_attr<'a>(attrs_str: &'a str, name: &str) -> Option<&'a str> {
+		// Try double-quote then single-quote form
+		for q in ['"', '\'' ] {
+			let pattern = format!("{name}={q}");
+			if let Some(start) = attrs_str.find(&pattern) {
+				let rest = &attrs_str[start + pattern.len()..];
+				if let Some(end) = rest.find(q) {
+					return Some(&rest[..end]);
+				}
+			}
+		}
+		None
+	}
+
+	let mut map = std::collections::HashMap::new();
+	let mut search = svg;
+
+	while let Some(text_start) = search.find("<text") {
+		search = &search[text_start..];
+
+		// Find the end of the opening <text ...> tag
+		let tag_end = search.find('>').unwrap_or(search.len());
+		let text_tag = &search[..=tag_end];
+
+		// Extract the id of this <text> element
+		let text_id = get_attr(text_tag, "id").unwrap_or("").to_string();
+
+		// Advance past this tag and look for a nested <textPath ...>
+		search = &search[tag_end.saturating_add(1).min(search.len())..];
+
+		if let Some(tp_start) = search.find("<textPath") {
+			let tp_end = search[tp_start..].find('>').map(|e| tp_start + e).unwrap_or(search.len());
+			let tp_tag = &search[tp_start..=tp_end];
+
+			let attrs = TextPathAttrs {
+				method: get_attr(tp_tag, "method").map(str::to_string),
+				spacing: get_attr(tp_tag, "spacing").map(str::to_string),
+				side: get_attr(tp_tag, "side").map(str::to_string),
+				text_length: get_attr(tp_tag, "textLength").and_then(|v| v.parse().ok()),
+				length_adjust: get_attr(tp_tag, "lengthAdjust").map(str::to_string),
+			};
+			map.insert(text_id, attrs);
+		}
+	}
+
+	map
+}
+
 /// Import a usvg node as the root of an SVG import operation.
 ///
 /// The root layer uses the full `move_layer_to_stack` (with push/collision logic) to correctly
@@ -551,6 +625,7 @@ fn import_usvg_node(
 	parent: LayerNodeIdentifier,
 	insert_index: usize,
 	graphite_gradient_stops: &HashMap<String, GradientStops>,
+	textpath_attrs: &HashMap<String, TextPathAttrs>,
 ) {
 	let layer = modify_inputs.create_layer(id);
 
@@ -571,7 +646,7 @@ fn import_usvg_node(
 			modify_inputs.import = true;
 
 			for child in group.children() {
-				let extent = import_usvg_node_inner(modify_inputs, child, NodeId::new(), layer, 0, graphite_gradient_stops, &mut group_extents_map);
+				let extent = import_usvg_node_inner(modify_inputs, child, NodeId::new(), layer, 0, graphite_gradient_stops, &mut group_extents_map, textpath_attrs);
 				child_extents_svg_order.push(extent);
 			}
 
@@ -596,7 +671,7 @@ fn import_usvg_node(
 			warn!("Skip image");
 		}
 		usvg::Node::Text(text) => {
-			import_usvg_text(modify_inputs, text, node.abs_transform(), layer, parent, insert_index);
+			import_usvg_text(modify_inputs, text, node.abs_transform(), layer, parent, insert_index, textpath_attrs);
 		}
 	}
 }
@@ -614,6 +689,7 @@ fn import_usvg_node_inner(
 	insert_index: usize,
 	graphite_gradient_stops: &HashMap<String, GradientStops>,
 	group_extents_map: &mut HashMap<LayerNodeIdentifier, Vec<u32>>,
+	textpath_attrs: &HashMap<String, TextPathAttrs>,
 ) -> u32 {
 	let layer = modify_inputs.create_layer(id);
 	modify_inputs.network_interface.move_layer_to_stack_for_import(layer, parent, insert_index, &[]);
@@ -623,7 +699,7 @@ fn import_usvg_node_inner(
 		usvg::Node::Group(group) => {
 			let mut child_extents: Vec<u32> = Vec::new();
 			for child in group.children() {
-				let extent = import_usvg_node_inner(modify_inputs, child, NodeId::new(), layer, 0, graphite_gradient_stops, group_extents_map);
+				let extent = import_usvg_node_inner(modify_inputs, child, NodeId::new(), layer, 0, graphite_gradient_stops, group_extents_map, textpath_attrs);
 				child_extents.push(extent);
 			}
 			modify_inputs.layer_node = Some(layer);
@@ -642,7 +718,7 @@ fn import_usvg_node_inner(
 			0
 		}
 		usvg::Node::Text(text) => {
-			import_usvg_text(modify_inputs, text, node.abs_transform(), layer, parent, insert_index);
+			import_usvg_text(modify_inputs, text, node.abs_transform(), layer, parent, insert_index, textpath_attrs);
 			0
 		}
 		usvg::Node::Path(path) => {
@@ -675,8 +751,12 @@ fn import_usvg_path(modify_inputs: &mut ModifyInputsContext, node: &usvg::Node,
 	}
 }
 
-fn import_usvg_text(modify_inputs: &mut ModifyInputsContext, text: &usvg::Text, transform: usvg::Transform, layer: LayerNodeIdentifier, parent: LayerNodeIdentifier, insert_index: usize) {
-	use graphene_std::text::TextAnchor;
+fn import_usvg_text(modify_inputs: &mut ModifyInputsContext, text: &usvg::Text, transform: usvg::Transform, layer: LayerNodeIdentifier, parent: LayerNodeIdentifier, insert_index: usize, textpath_attrs: &HashMap<String, TextPathAttrs>) {
+	use graphene_std::text::{LengthAdjust, TextAnchor, TextPathMethod, TextPathSide, TextPathSpacing};
+
+	// Look up pre-parsed textPath attrs using the <text> element id (or "" for unidentified elements)
+	let text_id = text.id();
+	let tp_attrs = textpath_attrs.get(text_id).cloned().unwrap_or_default();
 
 	for (i, chunk) in text.chunks().iter().enumerate() {
 		let current_layer = if i == 0 {
@@ -717,7 +797,25 @@ fn import_usvg_text(modify_inputs: &mut ModifyInputsContext, text: &usvg::Text,
 				transform.tx as f64,
 				transform.ty as f64,
 			]);
-			modify_inputs.insert_text_on_path(chunk.text().to_string(), font, font_size, letter_spacing, path_subpaths, start_offset, anchor, affine, current_layer);
+			// Translate pre-parsed attrs to typed enums
+			let method = match tp_attrs.method.as_deref() {
+				Some("stretch") => TextPathMethod::Stretch,
+				_ => TextPathMethod::Align,
+			};
+			let spacing = match tp_attrs.spacing.as_deref() {
+				Some("auto") => TextPathSpacing::Auto,
+				_ => TextPathSpacing::Exact,
+			};
+			let side = match tp_attrs.side.as_deref() {
+				Some("right") => TextPathSide::Right,
+				_ => TextPathSide::Left,
+			};
+			let length_adjust = match tp_attrs.length_adjust.as_deref() {
+				Some("spacingAndGlyphs") => LengthAdjust::SpacingAndGlyphs,
+				_ => LengthAdjust::Spacing,
+			};
+
+			modify_inputs.insert_text_on_path(chunk.text().to_string(), font, font_size, letter_spacing, path_subpaths, start_offset, anchor, side, method, spacing, tp_attrs.text_length, length_adjust, affine, current_layer);
 			modify_inputs.fill_set(Fill::Solid(Color::BLACK));
 		} else {
 			// Regular text fallback

editor/src/messages/portfolio/document/graph_operation/utility_types.rs

@@ -299,6 +299,11 @@ impl<'a> ModifyInputsContext<'a> {
 		path_subpaths: Vec<Subpath<PointId>>,
 		start_offset: f64,
 		text_anchor: TextAnchor,
+		side: graphene_std::text::TextPathSide,
+		method: graphene_std::text::TextPathMethod,
+		spacing: graphene_std::text::TextPathSpacing,
+		text_length: Option<f64>,
+		length_adjust: graphene_std::text::LengthAdjust,
 		transform: DAffine2,
 		layer: LayerNodeIdentifier,
 	) {
@@ -307,6 +312,9 @@ impl<'a> ModifyInputsContext<'a> {
 		// Create the path vector object
 		let path_vector = Table::new_from_element(Vector::from_subpaths(path_subpaths, true));
 
+		let has_text_length = text_length.is_some();
+		let text_length_val = text_length.unwrap_or(0.0);
+
 		// Create the Text On Path node directly using the vector as a value input
 		let text_on_path_node = resolve_proto_node_type(graphene_std::text::text_on_path::IDENTIFIER)
 			.expect("Text On Path node does not exist")
@@ -318,9 +326,17 @@ impl<'a> ModifyInputsContext<'a> {
 				Some(NodeInput::value(TaggedValue::F64(font_size), false)),
 				Some(NodeInput::value(TaggedValue::F64(character_spacing), false)),
 				Some(NodeInput::value(TaggedValue::F64(start_offset), false)), // start_offset
-				Some(NodeInput::value(TaggedValue::Bool(false), false)),       // start_offset_percent
-				Some(NodeInput::value(TaggedValue::TextPathSide(TextPathSide::Left), false)),
+				Some(NodeInput::value(TaggedValue::Bool(false), false)),        // start_offset_percent
+				Some(NodeInput::value(TaggedValue::TextPathSide(side), false)),
 				Some(NodeInput::value(TaggedValue::TextAnchor(text_anchor), false)),
+				Some(NodeInput::value(TaggedValue::TextPathMethod(method), false)),
+				Some(NodeInput::value(TaggedValue::TextPathSpacing(spacing), false)),
+				Some(NodeInput::value(TaggedValue::Bool(has_text_length), false)), // has_text_length
+				Some(NodeInput::value(TaggedValue::F64(text_length_val), false)),  // text_length
+				Some(NodeInput::value(TaggedValue::LengthAdjust(length_adjust), false)),
+				Some(NodeInput::value(TaggedValue::Bool(false), false)), // has_path_length
+				Some(NodeInput::value(TaggedValue::F64(0.0), false)),    // path_length
+				Some(NodeInput::value(TaggedValue::Bool(false), false)), // rtl
 			]);
 
 		let text_on_path_id = NodeId::new();

node-graph/graph-craft/src/document/value.rs

@@ -275,6 +275,9 @@ tagged_value! {
 	TextAlign(text_nodes::TextAlign),
 	TextPathSide(text_nodes::text_on_path::TextPathSide),
 	TextAnchor(text_nodes::text_on_path::TextAnchor),
+	TextPathMethod(text_nodes::text_on_path::TextPathMethod),
+	TextPathSpacing(text_nodes::text_on_path::TextPathSpacing),
+	LengthAdjust(text_nodes::text_on_path::LengthAdjust),
 	ScaleType(core_types::transform::ScaleType),
 }
 

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,64 @@ 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() {
+			// SVG export: emit <text><textPath> instead of raw glyph outlines
+			if render_params.for_export {
+				if let Some(ref meta) = row.element.text_on_path_metadata {
+					let path_id = format!("textpath-{}", generate_uuid());
+
+					// Store the reference path in <defs>
+					write!(
+						&mut render.svg_defs,
+						r#"<path id="{path_id}" d="{}" fill="none"/>"#,
+						meta.path_d
+					)
+					.unwrap();
+
+					// Build font CSS style string
+					let font_style_css = format!(
+						"font-family: {}; font-size: {}px; font-style: {};",
+						meta.font_family, meta.font_size, meta.font_style
+					);
+
+					// Build startOffset attribute value
+					let start_offset_attr = if meta.start_offset_percent {
+						format!("{}%", meta.start_offset * 100.0)
+					} else {
+						format!("{}", meta.start_offset)
+					};
+
+					// Compose the full <text> element with a <textPath> child
+					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| {
+							let length_adjust = &meta.length_adjust;
+							format!(r#" textLength="{tl}" lengthAdjust="{length_adjust}""#)
+						})
+						.unwrap_or_default();
+
+					// Only emit side as xlink:href reversal note — side="right" means path was reversed internally
+					let side_attr = if meta.side == "right" { r#" side="right""# } else { "" };
+
+					// text-anchor maps to SVG text-anchor property
+					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
 	}
 }