Move the "Text" category nodes from gcore/src/logic.rs to text/src/lib.rs (#4042)

Move the String category nodes from gcore/src/logic.rs to text/src/lib.rs

Cargo.lock

@@ -1990,7 +1990,6 @@ dependencies = [
  "node-macro",
  "raster-types",
  "serde",
- "serde_json",
  "tsify",
  "wasm-bindgen",
 ]
@@ -3082,6 +3081,7 @@ version = "0.1.0"
 dependencies = [
  "core-types",
  "glam",
+ "graphic-types",
  "log",
  "math-parser",
  "node-macro",
@@ -5503,7 +5503,9 @@ dependencies = [
  "log",
  "node-macro",
  "parley",
+ "raster-types",
  "serde",
+ "serde_json",
  "skrifa 0.40.0",
  "tsify",
  "vector-types",

editor/src/messages/portfolio/document/node_graph/document_node_definitions.rs

@@ -537,7 +537,7 @@ fn document_node_definitions() -> HashMap<DefinitionIdentifier, DocumentNodeDefi
 							},
 							// 11: Switch (closed → count, open → max(count - 1, 1) as denominator)
 							DocumentNode {
-								implementation: DocumentNodeImplementation::ProtoNode(logic::switch::IDENTIFIER),
+								implementation: DocumentNodeImplementation::ProtoNode(math_nodes::switch::IDENTIFIER),
 								inputs: vec![NodeInput::node(NodeId(10), 0), NodeInput::node(NodeId(17), 0), NodeInput::node(NodeId(18), 0)],
 								..Default::default()
 							},

editor/src/messages/portfolio/document/node_graph/node_properties.rs

@@ -196,7 +196,6 @@ pub(crate) fn property_from_type(
 				Some("Fraction") => number_widget(default_info, number_input.mode_range().min(min(0.)).max(max(1.))).into(),
 				Some("Progression") => progression_widget(default_info, number_input.min(min(0.))).into(),
 				Some("SignedInteger") => number_widget(default_info, number_input.int()).into(),
-				Some("IntegerCount") => number_widget(default_info, number_input.int().min(min(1.))).into(),
 				Some("SeedValue") => number_widget(default_info, number_input.int().min(min(0.))).into(),
 				Some("PixelSize") => vec2_widget(default_info, "X", "Y", unit.unwrap_or(" px"), None, false),
 				Some("TextArea") => text_area_widget(default_info).into(),

editor/src/messages/portfolio/document_migration.rs

@@ -108,10 +108,6 @@ const NODE_REPLACEMENTS: &[NodeReplacement<'static>] = &[
 		node: graphene_std::animation::real_time::IDENTIFIER,
 		aliases: &["graphene_core::animation::RealTimeNode"],
 	},
-	NodeReplacement {
-		node: graphene_std::logic::serialize::IDENTIFIER,
-		aliases: &["graphene_core::logic::SerializeNode"],
-	},
 	NodeReplacement {
 		node: graphene_std::debug::size_of::IDENTIFIER,
 		aliases: &["graphene_core::ops::SizeOfNode"],
@@ -120,34 +116,6 @@ const NODE_REPLACEMENTS: &[NodeReplacement<'static>] = &[
 		node: graphene_std::debug::some::IDENTIFIER,
 		aliases: &["graphene_core::ops::SomeNode"],
 	},
-	NodeReplacement {
-		node: graphene_std::logic::string_concatenate::IDENTIFIER,
-		aliases: &["graphene_core::logic::StringConcatenateNode"],
-	},
-	NodeReplacement {
-		node: graphene_std::logic::string_length::IDENTIFIER,
-		aliases: &["graphene_core::logic::StringLengthNode"],
-	},
-	NodeReplacement {
-		node: graphene_std::logic::string_replace::IDENTIFIER,
-		aliases: &["graphene_core::logic::StringReplaceNode"],
-	},
-	NodeReplacement {
-		node: graphene_std::logic::string_slice::IDENTIFIER,
-		aliases: &["graphene_core::logic::StringSliceNode"],
-	},
-	NodeReplacement {
-		node: graphene_std::logic::string_split::IDENTIFIER,
-		aliases: &["graphene_core::logic::StringSplitNode"],
-	},
-	NodeReplacement {
-		node: graphene_std::logic::switch::IDENTIFIER,
-		aliases: &["graphene_core::logic::SwitchNode"],
-	},
-	NodeReplacement {
-		node: graphene_std::logic::to_string::IDENTIFIER,
-		aliases: &["graphene_core::logic::ToStringNode"],
-	},
 	NodeReplacement {
 		node: graphene_std::debug::unwrap_option::IDENTIFIER,
 		aliases: &["graphene_core::ops::UnwrapNode", "graphene_core::debug::UnwrapNode"],
@@ -416,10 +384,6 @@ const NODE_REPLACEMENTS: &[NodeReplacement<'static>] = &[
 		node: graphene_std::math_nodes::sine_inverse::IDENTIFIER,
 		aliases: &["graphene_math_nodes::SineInverseNode", "graphene_core::ops::SineInverseNode"],
 	},
-	NodeReplacement {
-		node: graphene_std::math_nodes::string_value::IDENTIFIER,
-		aliases: &["graphene_math_nodes::StringValueNode", "graphene_core::ops::StringValueNode"],
-	},
 	NodeReplacement {
 		node: graphene_std::math_nodes::subtract::IDENTIFIER,
 		aliases: &["graphene_math_nodes::SubtractNode", "graphene_core::ops::SubtractNode"],
@@ -680,6 +644,46 @@ const NODE_REPLACEMENTS: &[NodeReplacement<'static>] = &[
 		node: graphene_std::text::text::IDENTIFIER,
 		aliases: &["graphene_core::text::text::TextNode", "graphene_core::text::TextGeneratorNode", "graphene_core::text::TextNode"],
 	},
+	NodeReplacement {
+		node: graphene_std::text_nodes::string_value::IDENTIFIER,
+		aliases: &["graphene_math_nodes::StringValueNode", "graphene_core::ops::StringValueNode", "math_nodes::StringValueNode"],
+	},
+	NodeReplacement {
+		node: graphene_std::text_nodes::string_concatenate::IDENTIFIER,
+		aliases: &["graphene_core::logic::StringConcatenateNode"],
+	},
+	NodeReplacement {
+		node: graphene_std::text_nodes::string_length::IDENTIFIER,
+		aliases: &["graphene_core::logic::StringLengthNode"],
+	},
+	NodeReplacement {
+		node: graphene_std::text_nodes::string_replace::IDENTIFIER,
+		aliases: &["graphene_core::logic::StringReplaceNode"],
+	},
+	NodeReplacement {
+		node: graphene_std::text_nodes::string_slice::IDENTIFIER,
+		aliases: &["graphene_core::logic::StringSliceNode"],
+	},
+	NodeReplacement {
+		node: graphene_std::text_nodes::string_split::IDENTIFIER,
+		aliases: &["graphene_core::logic::StringSplitNode"],
+	},
+	NodeReplacement {
+		node: graphene_std::math_nodes::switch::IDENTIFIER,
+		aliases: &["graphene_core::logic::SwitchNode"],
+	},
+	NodeReplacement {
+		node: graphene_std::text_nodes::to_string::IDENTIFIER,
+		aliases: &["graphene_core::logic::ToStringNode"],
+	},
+	NodeReplacement {
+		node: graphene_std::text_nodes::json_get::IDENTIFIER,
+		aliases: &["graphene_core::logic::JsonGetNode"],
+	},
+	NodeReplacement {
+		node: graphene_std::text_nodes::serialize::IDENTIFIER,
+		aliases: &["graphene_core::logic::SerializeNode"],
+	},
 	// ================================
 	// transform
 	// ================================

node-graph/nodes/gcore/Cargo.toml

@@ -27,7 +27,6 @@ node-macro = { workspace = true }
 dyn-any = { workspace = true }
 glam = { workspace = true }
 log = { workspace = true }
-serde_json = { workspace = true }
 
 # Optional workspace dependencies
 serde = { workspace = true, optional = true }

node-graph/nodes/gcore/src/animation.rs

@@ -60,7 +60,7 @@ fn animation_time(
 	ctx.try_animation_time().unwrap_or_default() * rate
 }
 
-#[node_macro::node(category("Animation"))]
+#[node_macro::node(category("Debug"))]
 async fn quantize_real_time<T>(
 	ctx: impl Ctx + ExtractAll + CloneVarArgs,
 	#[implementations(
@@ -103,7 +103,7 @@ async fn quantize_real_time<T>(
 	value.eval(Some(new_context.into())).await
 }
 
-#[node_macro::node(category("Animation"))]
+#[node_macro::node(category("Debug"))]
 async fn quantize_animation_time<T>(
 	ctx: impl Ctx + ExtractAll + CloneVarArgs,
 	#[implementations(

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

@@ -3,7 +3,6 @@ pub mod context;
 pub mod context_modification;
 pub mod debug;
 pub mod extract_xy;
-pub mod logic;
 pub mod memo;
 pub mod ops;
 
@@ -13,6 +12,5 @@ pub use context::*;
 pub use context_modification::*;
 pub use debug::*;
 pub use extract_xy::*;
-pub use logic::*;
 pub use memo::*;
 pub use ops::*;

node-graph/nodes/gcore/src/logic.rs

@@ -1,180 +0,0 @@
-use core_types::Color;
-use core_types::registry::types::TextArea;
-use core_types::table::Table;
-use core_types::{Context, Ctx};
-use glam::{DAffine2, DVec2};
-use graphic_types::vector_types::GradientStops;
-use graphic_types::{Artboard, Graphic, Vector};
-use raster_types::{CPU, GPU, Raster};
-
-/// Type-asserts a value to be a string.
-#[node_macro::node(category("Debug"))]
-fn to_string(_: impl Ctx, value: String) -> String {
-	value
-}
-
-/// Converts a value to a JSON string representation.
-#[node_macro::node(category("Text"))]
-fn serialize<T: serde::Serialize>(
-	_: impl Ctx,
-	#[implementations(String, bool, f64, u32, u64, DVec2, DAffine2, /* Table<Artboard>, Table<Graphic>, Table<Vector>, */ Table<Raster<CPU>>, Table<Color> /* , Table<GradientStops> */)] value: T,
-) -> String {
-	serde_json::to_string(&value).unwrap_or_else(|_| "Serialization Error".to_string())
-}
-
-/// Joins two strings together.
-#[node_macro::node(category("Text"))]
-fn string_concatenate(_: impl Ctx, #[implementations(String)] first: String, second: TextArea) -> String {
-	first.clone() + &second
-}
-
-/// Replaces all occurrences of "From" with "To" in the input string.
-#[node_macro::node(category("Text"))]
-fn string_replace(_: impl Ctx, string: String, from: TextArea, to: TextArea) -> String {
-	string.replace(&from, &to)
-}
-
-/// Extracts a substring from the input string, starting at "Start" and ending before "End".
-/// Negative indices count from the end of the string.
-/// If "Start" equals or exceeds "End", the result is an empty string.
-#[node_macro::node(category("Text"))]
-fn string_slice(_: impl Ctx, string: String, start: f64, end: f64) -> String {
-	let total_chars = string.chars().count();
-
-	let start = if start < 0. {
-		total_chars.saturating_sub(start.abs() as usize)
-	} else {
-		(start as usize).min(total_chars)
-	};
-	let end = if end <= 0. {
-		total_chars.saturating_sub(end.abs() as usize)
-	} else {
-		(end as usize).min(total_chars)
-	};
-
-	if start >= end {
-		return String::new();
-	}
-
-	string.chars().skip(start).take(end - start).collect()
-}
-
-// TODO: Return u32, u64, or usize instead of f64 after #1621 is resolved and has allowed us to implement automatic type conversion in the node graph for nodes with generic type inputs.
-// TODO: (Currently automatic type conversion only works for concrete types, via the Graphene preprocessor and not the full Graphene type system.)
-/// Counts the number of characters in a string.
-#[node_macro::node(category("Text"))]
-fn string_length(_: impl Ctx, string: String) -> f64 {
-	string.chars().count() as f64
-}
-
-/// Splits a string into a list of substrings based on the specified delimeter.
-/// For example, the delimeter "," will split "a,b,c" into the strings "a", "b", and "c".
-#[node_macro::node(category("Text"))]
-fn string_split(
-	_: impl Ctx,
-	/// The string to split into substrings.
-	string: String,
-	/// The character(s) that separate the substrings. These are not included in the outputs.
-	#[default("\\n")]
-	delimeter: String,
-	/// Whether to convert escape sequences found in the delimeter into their corresponding characters:
-	/// "\n" (newline), "\r" (carriage return), "\t" (tab), "\0" (null), and "\\" (backslash).
-	#[default(true)]
-	delimeter_escaping: bool,
-) -> Vec<String> {
-	let delimeter = if delimeter_escaping {
-		delimeter.replace("\\n", "\n").replace("\\r", "\r").replace("\\t", "\t").replace("\\0", "\0").replace("\\\\", "\\")
-	} else {
-		delimeter
-	};
-
-	string.split(&delimeter).map(str::to_string).collect()
-}
-
-/// Gets a value from either a json object or array given as a string input.
-/// For example, for the input {"name": "ferris"} the key "name" will return "ferris".
-#[node_macro::node(category("Text"))]
-fn json_get(
-	_: impl Ctx,
-	/// The json data.
-	data: String,
-	/// The key to index the object with.
-	key: String,
-) -> String {
-	use serde_json::Value;
-	let Ok(value): Result<Value, _> = serde_json::from_str(&data) else {
-		return "Input is not valid json".into();
-	};
-	match value {
-		Value::Array(ref arr) => {
-			let Ok(index): Result<usize, _> = key.parse() else {
-				log::error!("Json input is an array, but key is not a number");
-				return String::new();
-			};
-			let Some(value) = arr.get(index) else {
-				log::error!("Index {} out of bounds for len {}", index, arr.len());
-				return String::new();
-			};
-			value.to_string()
-		}
-		Value::Object(map) => {
-			let Some(value) = map.get(&key) else {
-				log::error!("Key {key} not found in object");
-				return String::new();
-			};
-			match value {
-				Value::String(s) => s.clone(),
-				Value::Number(n) => n.to_string(),
-				complex => complex.to_string(),
-			}
-		}
-		_ => String::new(),
-	}
-}
-
-/// Evaluates either the "If True" or "If False" input branch based on whether the input condition is true or false.
-#[node_macro::node(category("Math: Logic"))]
-async fn switch<T, C: Send + 'n + Clone>(
-	#[implementations(Context)] ctx: C,
-	condition: bool,
-	#[expose]
-	#[implementations(
-		Context -> String,
-		Context -> bool,
-		Context -> f32,
-		Context -> f64,
-		Context -> u32,
-		Context -> u64,
-		Context -> DVec2,
-		Context -> DAffine2,
-		Context -> Table<Artboard>,
-		Context -> Table<Graphic>,
-		Context -> Table<Vector>,
-		Context -> Table<Raster<CPU>>,
-		Context -> Table<Raster<GPU>>,
-		Context -> Table<Color>,
-		Context -> Table<GradientStops>,
-	)]
-	if_true: impl Node<C, Output = T>,
-	#[expose]
-	#[implementations(
-		Context -> String,
-		Context -> bool,
-		Context -> f32,
-		Context -> f64,
-		Context -> u32,
-		Context -> u64,
-		Context -> DVec2,
-		Context -> DAffine2,
-		Context -> Table<Artboard>,
-		Context -> Table<Graphic>,
-		Context -> Table<Vector>,
-		Context -> Table<Raster<CPU>>,
-		Context -> Table<Raster<GPU>>,
-		Context -> Table<Color>,
-		Context -> Table<GradientStops>,
-	)]
-	if_false: impl Node<C, Output = T>,
-) -> T {
-	if condition { if_true.eval(ctx).await } else { if_false.eval(ctx).await }
-}

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

@@ -78,10 +78,6 @@ pub mod math {
 	}
 }
 
-pub mod logic {
-	pub use graphene_core::logic::*;
-}
-
 pub mod context {
 	pub use graphene_core::context::*;
 }

node-graph/nodes/math/Cargo.toml

@@ -9,6 +9,7 @@ license = "MIT OR Apache-2.0"
 [dependencies]
 core-types = { workspace = true }
 node-macro = { workspace = true }
+graphic-types = { workspace = true }
 vector-types = { workspace = true }
 
 # Workspace dependencies

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

@@ -1,8 +1,11 @@
-use core_types::registry::types::{Fraction, Percentage, PixelSize, TextArea};
+use core_types::Context;
+use core_types::registry::types::{Fraction, Percentage, PixelSize};
 use core_types::table::Table;
 use core_types::transform::Footprint;
 use core_types::{Color, Ctx, num_traits};
 use glam::{DAffine2, DVec2};
+use graphic_types::raster_types::{CPU, GPU, Raster};
+use graphic_types::{Artboard, Graphic, Vector};
 use log::warn;
 use math_parser::ast;
 use math_parser::context::{EvalContext, NothingMap, ValueProvider};
@@ -735,6 +738,53 @@ fn logical_not(
 	!input
 }
 
+/// Evaluates either the "If True" or "If False" input branch based on whether the input condition is true or false.
+#[node_macro::node(category("Math: Logic"))]
+async fn switch<T, C: Send + 'n + Clone>(
+	#[implementations(Context)] ctx: C,
+	condition: bool,
+	#[expose]
+	#[implementations(
+		Context -> String,
+		Context -> bool,
+		Context -> f32,
+		Context -> f64,
+		Context -> u32,
+		Context -> u64,
+		Context -> DVec2,
+		Context -> DAffine2,
+		Context -> Table<Artboard>,
+		Context -> Table<Graphic>,
+		Context -> Table<Vector>,
+		Context -> Table<Raster<CPU>>,
+		Context -> Table<Raster<GPU>>,
+		Context -> Table<Color>,
+		Context -> Table<GradientStops>,
+	)]
+	if_true: impl Node<C, Output = T>,
+	#[expose]
+	#[implementations(
+		Context -> String,
+		Context -> bool,
+		Context -> f32,
+		Context -> f64,
+		Context -> u32,
+		Context -> u64,
+		Context -> DVec2,
+		Context -> DAffine2,
+		Context -> Table<Artboard>,
+		Context -> Table<Graphic>,
+		Context -> Table<Vector>,
+		Context -> Table<Raster<CPU>>,
+		Context -> Table<Raster<GPU>>,
+		Context -> Table<Color>,
+		Context -> Table<GradientStops>,
+	)]
+	if_false: impl Node<C, Output = T>,
+) -> T {
+	if condition { if_true.eval(ctx).await } else { if_false.eval(ctx).await }
+}
+
 /// Constructs a bool value which may be set to true or false.
 #[node_macro::node(category("Value"))]
 fn bool_value(_: impl Ctx, _primary: (), #[name("Bool")] bool_value: bool) -> bool {
@@ -823,12 +873,6 @@ fn sample_gradient(_: impl Ctx, _primary: (), gradient: Table<GradientStops>, po
 	Table::new_from_element(color)
 }
 
-/// Constructs a string value which may be set to any plain text.
-#[node_macro::node(category("Value"))]
-fn string_value(_: impl Ctx, _primary: (), string: TextArea) -> String {
-	string
-}
-
 /// Constructs a footprint value which may be set to any transformation of a unit square describing a render area, and a render resolution at least 1x1 integer pixels.
 #[node_macro::node(category("Value"))]
 fn footprint_value(_: impl Ctx, _primary: (), transform: DAffine2, #[default(100., 100.)] resolution: PixelSize) -> Footprint {

node-graph/nodes/text/Cargo.toml

@@ -13,6 +13,7 @@ wasm = ["core-types/wasm", "tsify", "wasm-bindgen"]
 [dependencies]
 # Local dependencies
 core-types = { workspace = true }
+raster-types = { workspace = true }
 vector-types = { workspace = true }
 node-macro = { workspace = true }
 
@@ -22,6 +23,7 @@ glam = { workspace = true }
 parley = { workspace = true }
 skrifa = { workspace = true }
 log = { workspace = true }
+serde_json = { workspace = true }
 
 # Optional workspace dependencies
 serde = { workspace = true, optional = true }

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

@@ -3,13 +3,19 @@ mod path_builder;
 mod text_context;
 mod to_path;
 
+use core_types::Color;
+use core_types::Ctx;
+use core_types::registry::types::TextArea;
+use core_types::table::Table;
 use dyn_any::DynAny;
-pub use font_cache::*;
+use glam::{DAffine2, DVec2};
-pub use text_context::TextContext;
+use raster_types::{CPU, Raster};
-pub use to_path::*;
 
 // Re-export for convenience
 pub use core_types as gcore;
+pub use font_cache::*;
+pub use text_context::TextContext;
+pub use to_path::*;
 pub use vector_types;
 
 /// Alignment of lines of type within a text block.
@@ -62,3 +68,134 @@ impl Default for TypesettingConfig {
 		}
 	}
 }
+
+/// Constructs a string value which may be set to any plain text.
+#[node_macro::node(category("Value"))]
+fn string_value(_: impl Ctx, _primary: (), string: TextArea) -> String {
+	string
+}
+
+/// Type-asserts a value to be a string.
+#[node_macro::node(category("Debug"))]
+fn to_string(_: impl Ctx, value: String) -> String {
+	value
+}
+
+/// Joins two strings together.
+#[node_macro::node(category("Text"))]
+fn string_concatenate(_: impl Ctx, #[implementations(String)] first: String, second: TextArea) -> String {
+	first.clone() + &second
+}
+
+/// Replaces all occurrences of "From" with "To" in the input string.
+#[node_macro::node(category("Text"))]
+fn string_replace(_: impl Ctx, string: String, from: TextArea, to: TextArea) -> String {
+	string.replace(&from, &to)
+}
+
+/// Extracts a substring from the input string, starting at "Start" and ending before "End".
+/// Negative indices count from the end of the string.
+/// If "Start" equals or exceeds "End", the result is an empty string.
+#[node_macro::node(category("Text"))]
+fn string_slice(_: impl Ctx, string: String, start: f64, end: f64) -> String {
+	let total_chars = string.chars().count();
+
+	let start = if start < 0. {
+		total_chars.saturating_sub(start.abs() as usize)
+	} else {
+		(start as usize).min(total_chars)
+	};
+	let end = if end <= 0. {
+		total_chars.saturating_sub(end.abs() as usize)
+	} else {
+		(end as usize).min(total_chars)
+	};
+
+	if start >= end {
+		return String::new();
+	}
+
+	string.chars().skip(start).take(end - start).collect()
+}
+
+// TODO: Return u32, u64, or usize instead of f64 after #1621 is resolved and has allowed us to implement automatic type conversion in the node graph for nodes with generic type inputs.
+// TODO: (Currently automatic type conversion only works for concrete types, via the Graphene preprocessor and not the full Graphene type system.)
+/// Counts the number of characters in a string.
+#[node_macro::node(category("Text"))]
+fn string_length(_: impl Ctx, string: String) -> f64 {
+	string.chars().count() as f64
+}
+
+/// Splits a string into a list of substrings based on the specified delimeter.
+/// For example, the delimeter "," will split "a,b,c" into the strings "a", "b", and "c".
+#[node_macro::node(category("Text"))]
+fn string_split(
+	_: impl Ctx,
+	/// The string to split into substrings.
+	string: String,
+	/// The character(s) that separate the substrings. These are not included in the outputs.
+	#[default("\\n")]
+	delimeter: String,
+	/// Whether to convert escape sequences found in the delimeter into their corresponding characters:
+	/// "\n" (newline), "\r" (carriage return), "\t" (tab), "\0" (null), and "\\" (backslash).
+	#[default(true)]
+	delimeter_escaping: bool,
+) -> Vec<String> {
+	let delimeter = if delimeter_escaping {
+		delimeter.replace("\\n", "\n").replace("\\r", "\r").replace("\\t", "\t").replace("\\0", "\0").replace("\\\\", "\\")
+	} else {
+		delimeter
+	};
+
+	string.split(&delimeter).map(str::to_string).collect()
+}
+
+/// Gets a value from either a json object or array given as a string input.
+/// For example, for the input {"name": "ferris"} the key "name" will return "ferris".
+#[node_macro::node(category("Text"))]
+fn json_get(
+	_: impl Ctx,
+	/// The json data.
+	data: String,
+	/// The key to index the object with.
+	key: String,
+) -> String {
+	use serde_json::Value;
+	let Ok(value): Result<Value, _> = serde_json::from_str(&data) else {
+		return "Input is not valid json".into();
+	};
+	match value {
+		Value::Array(ref arr) => {
+			let Ok(index): Result<usize, _> = key.parse() else {
+				log::error!("Json input is an array, but key is not a number");
+				return String::new();
+			};
+			let Some(value) = arr.get(index) else {
+				log::error!("Index {} out of bounds for len {}", index, arr.len());
+				return String::new();
+			};
+			value.to_string()
+		}
+		Value::Object(map) => {
+			let Some(value) = map.get(&key) else {
+				log::error!("Key {key} not found in object");
+				return String::new();
+			};
+			match value {
+				Value::String(s) => s.clone(),
+				Value::Number(n) => n.to_string(),
+				complex => complex.to_string(),
+			}
+		}
+		_ => String::new(),
+	}
+}
+
+/// Converts a value to a JSON string representation.
+#[node_macro::node(category("Text"))]
+fn serialize<T: serde::Serialize>(
+	_: impl Ctx,
+	#[implementations(String, bool, f64, u32, u64, DVec2, DAffine2, /* Table<Artboard>, Table<Graphic>, Table<Vector>, */ Table<Raster<CPU>>, Table<Color> /* , Table<GradientStops> */)] value: T,
+) -> String {
+	serde_json::to_string(&value).unwrap_or_else(|_| "Serialization Error".to_string())
+}