Centralize attribute strings in consts and rename "editor:layer" to "editor:layer_path" (#4076)

* Rename "editor:layer" to "editor:layer_path" and centralize it in a const

* Centralize "editor:merged_layers" in a const

* Centralize all other attributes in consts

* Rename consts with ATTR_ prefix

* Format

Author: Keavon

editor/src/messages/portfolio/document/data_panel/data_panel_message_handler.rs

@@ -993,7 +993,7 @@ fn table_node_id_path_layout_with_breadcrumb(path: &Table<NodeId>, data: &mut La
 /// Mirrors [`dispatch_value_widget`] but routes to [`TableRowLayout::layout_with_breadcrumb`].
 /// Returns `None` for unrecognized types.
 fn drilldown_attribute_layout(any: &dyn Any, data: &mut LayoutData) -> Option<Vec<LayoutGroup>> {
-	// `Table<NodeId>` is interpreted as a path (e.g. the `editor:layer` attribute), so each item's NodeId value
+	// `Table<NodeId>` is interpreted as a path (e.g. the `editor:layer_path` attribute), so each item's NodeId value
 	// resolves against the prefix made up of preceding items. Handled before the generic `Table<T>` blanket impl.
 	if let Some(path) = any.downcast_ref::<Table<NodeId>>() {
 		return Some(table_node_id_path_layout_with_breadcrumb(path, data));

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

@@ -239,12 +239,12 @@ fn document_node_definitions() -> HashMap<DefinitionIdentifier, DocumentNodeDefi
 								implementation: DocumentNodeImplementation::ProtoNode(graphic::path_of_subgraph::IDENTIFIER),
 								..Default::default()
 							},
-							// Stamp each item of the content with the parent layer's NodeId via the `editor:layer` attribute,
+							// Stamp each item of the content with the parent layer's NodeId via the `editor:layer_path` attribute,
 							// so editor tools (e.g. selection, click target routing) can trace data back to its owning layer.
 							DocumentNode {
 								inputs: vec![
 									NodeInput::node(NodeId(1), 0),
-									NodeInput::value(TaggedValue::String(String::from("editor:layer")), false),
+									NodeInput::value(TaggedValue::String(graphene_std::ATTR_EDITOR_LAYER_PATH.to_string()), false),
 									NodeInput::node(NodeId(2), 0),
 								],
 								implementation: DocumentNodeImplementation::ProtoNode(graphic::write_attribute::IDENTIFIER),
@@ -374,12 +374,12 @@ fn document_node_definitions() -> HashMap<DefinitionIdentifier, DocumentNodeDefi
 								implementation: DocumentNodeImplementation::ProtoNode(graphic::path_of_subgraph::IDENTIFIER),
 								..Default::default()
 							},
-							// Stamp each item of the content with the parent layer's NodeId via the `editor:layer` attribute,
+							// Stamp each item of the content with the parent layer's NodeId via the `editor:layer_path` attribute,
 							// so editor tools (e.g. selection, click target routing) can trace data back to its owning layer.
 							DocumentNode {
 								inputs: vec![
 									NodeInput::node(NodeId(0), 0),
-									NodeInput::value(TaggedValue::String(String::from("editor:layer")), false),
+									NodeInput::value(TaggedValue::String(graphene_std::ATTR_EDITOR_LAYER_PATH.to_string()), false),
 									NodeInput::node(NodeId(1), 0),
 								],
 								implementation: DocumentNodeImplementation::ProtoNode(graphic::write_attribute::IDENTIFIER),

editor/src/messages/portfolio/document/overlays/utility_types_native.rs

@@ -10,6 +10,7 @@ use crate::messages::prelude::ViewportMessageHandler;
 use core::borrow::Borrow;
 use core::f64::consts::{FRAC_PI_2, PI, TAU};
 use glam::{DAffine2, DVec2};
+use graphene_std::ATTR_TRANSFORM;
 use graphene_std::math::quad::Quad;
 use graphene_std::subpath::{self, Subpath};
 use graphene_std::table::Table;
@@ -1170,7 +1171,7 @@ impl OverlayContextInternal {
 			// Use the existing bezier_to_path infrastructure to convert Vector to BezPath
 			let mut path = BezPath::new();
 			let mut last_point = None;
-			let transform: DAffine2 = text_table.attribute_cloned_or_default("transform", index);
+			let transform: DAffine2 = text_table.attribute_cloned_or_default(ATTR_TRANSFORM, index);
 
 			let Some(element) = text_table.element(index) else { continue };
 			for (_, bezier, start_id, end_id) in element.segment_iter() {

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

@@ -33,6 +33,7 @@ pub use num_traits;
 use std::any::TypeId;
 use std::future::Future;
 use std::pin::Pin;
+pub use table::{ATTR_ALPHA_BLENDING, ATTR_EDITOR_LAYER_PATH, ATTR_EDITOR_MERGED_LAYERS, ATTR_END, ATTR_NAME, ATTR_START, ATTR_TRANSFORM, ATTR_TYPE};
 #[cfg(feature = "wasm")]
 pub use tsify;
 pub use types::Cow;

node-graph/libraries/core-types/src/table.rs

@@ -5,6 +5,45 @@ use dyn_any::{StaticType, StaticTypeSized};
 use glam::DAffine2;
 use std::fmt::Debug;
 
+// =====================================================================
+// Standard attribute keys used across the data flow
+// =====================================================================
+
+/// Attribute key for a row's `DAffine2` transformation, applied when rendering and when accumulating
+/// transforms through nested compositions.
+pub const ATTR_TRANSFORM: &str = "transform";
+
+/// Attribute key for a row's `AlphaBlending` (blend mode + opacity + fill + clip), composed
+/// multiplicatively through nested compositions.
+pub const ATTR_ALPHA_BLENDING: &str = "alpha_blending";
+
+/// Attribute key under which each row of an editor-aware layer stores a `Table<NodeId>` describing the
+/// path (from the root document network) to the layer node that owns the row. Editor tools use this to
+/// route clicks/selection back to the originating layer at any nesting depth.
+pub const ATTR_EDITOR_LAYER_PATH: &str = "editor:layer_path";
+
+/// Attribute key under which a row stores a `Table<Graphic>` snapshot of the upstream content that fed
+/// into a destructive merge (Boolean Operation, Flatten Path, Morph, Rasterize, etc.). The renderer
+/// recurses into this snapshot during metadata collection so the editor can still surface click targets
+/// for the original child layers after their content has been collapsed into a single output.
+pub const ATTR_EDITOR_MERGED_LAYERS: &str = "editor:merged_layers";
+
+/// Attribute key for the byte offset where a regex match begins in the input string, set by the
+/// `regex_find_all` and `regex_capture` text nodes.
+pub const ATTR_START: &str = "start";
+
+/// Attribute key for the byte offset where a regex match ends in the input string, set by the
+/// `regex_find_all` and `regex_capture` text nodes.
+pub const ATTR_END: &str = "end";
+
+/// Attribute key for a regex named-capture-group's name (empty for unnamed groups), set by the
+/// `regex_capture` text node.
+pub const ATTR_NAME: &str = "name";
+
+/// Attribute key for a JSON value's type (`"string"`, `"number"`, `"object"`, etc.), set by the
+/// `json_query_all` text node alongside each extracted value.
+pub const ATTR_TYPE: &str = "type";
+
 // =====================
 // TRAIT: AttributeValue
 // =====================
@@ -747,7 +786,7 @@ impl<T: BoundingBox> BoundingBox for Table<T> {
 	fn bounding_box(&self, transform: DAffine2, include_stroke: bool) -> RenderBoundingBox {
 		let mut combined_bounds = None;
 
-		for (element, row_transform) in self.iter_element_values().zip(self.iter_attribute_values_or_default::<DAffine2>("transform")) {
+		for (element, row_transform) in self.iter_element_values().zip(self.iter_attribute_values_or_default::<DAffine2>(ATTR_TRANSFORM)) {
 			match element.bounding_box(transform * row_transform, include_stroke) {
 				RenderBoundingBox::None => continue,
 				RenderBoundingBox::Infinite => return RenderBoundingBox::Infinite,
@@ -793,10 +832,10 @@ impl<T: graphene_hash::CacheHash> graphene_hash::CacheHash for Table<T> {
 		for element in self.iter_element_values() {
 			element.cache_hash(state);
 		}
-		for transform in self.iter_attribute_values_or_default::<DAffine2>("transform") {
+		for transform in self.iter_attribute_values_or_default::<DAffine2>(ATTR_TRANSFORM) {
 			graphene_hash::CacheHash::cache_hash(&transform, state);
 		}
-		for alpha_blending in self.iter_attribute_values_or_default::<crate::AlphaBlending>("alpha_blending") {
+		for alpha_blending in self.iter_attribute_values_or_default::<crate::AlphaBlending>(ATTR_ALPHA_BLENDING) {
 			alpha_blending.cache_hash(state);
 		}
 	}
@@ -811,14 +850,14 @@ impl<T: PartialEq> PartialEq for Table<T> {
 impl<T> ApplyTransform for Table<T> {
 	/// Right-multiplies the modification into each row's transform attribute.
 	fn apply_transform(&mut self, modification: &DAffine2) {
-		for transform in self.iter_attribute_values_mut_or_default::<DAffine2>("transform") {
+		for transform in self.iter_attribute_values_mut_or_default::<DAffine2>(ATTR_TRANSFORM) {
 			*transform *= *modification;
 		}
 	}
 
 	/// Left-multiplies the modification into each row's transform attribute.
 	fn left_apply_transform(&mut self, modification: &DAffine2) {
-		for transform in self.iter_attribute_values_mut_or_default::<DAffine2>("transform") {
+		for transform in self.iter_attribute_values_mut_or_default::<DAffine2>(ATTR_TRANSFORM) {
 			*transform = *modification * *transform;
 		}
 	}

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

@@ -1,12 +1,12 @@
 use crate::graphic::Graphic;
-use core_types::Color;
 use core_types::blending::AlphaBlending;
 use core_types::bounds::{BoundingBox, RenderBoundingBox};
 use core_types::math::quad::Quad;
 use core_types::render_complexity::RenderComplexity;
 use core_types::table::{Table, TableRow};
 use core_types::transform::Transform;
 use core_types::uuid::NodeId;
+use core_types::{ATTR_TRANSFORM, Color};
 use dyn_any::DynAny;
 use glam::{DAffine2, DVec2, IVec2};
 use graphene_hash::CacheHash;
@@ -52,7 +52,7 @@ impl BoundingBox for Artboard {
 
 		let mut combined_bounds = None;
 
-		for (element, row_transform) in self.content.iter_element_values().zip(self.content.iter_attribute_values_or_default::<DAffine2>("transform")) {
+		for (element, row_transform) in self.content.iter_element_values().zip(self.content.iter_attribute_values_or_default::<DAffine2>(ATTR_TRANSFORM)) {
 			match element.bounding_box(transform * row_transform, include_stroke) {
 				RenderBoundingBox::None => continue,
 				RenderBoundingBox::Infinite => return RenderBoundingBox::Infinite,
@@ -113,7 +113,7 @@ pub fn migrate_artboard<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Re
 		alpha_blending: Vec<AlphaBlending>,
 	}
 
-	// Attributes (transform, alpha_blending, editor:layer) are not serialized, so migration only needs
+	// Attributes (transform, alpha_blending, editor:layer_path) are not serialized, so migration only needs
 	// to recover the elements. Per-item attribute values are populated at runtime by the node graph.
 	Ok(match ArtboardFormat::deserialize(deserializer)? {
 		ArtboardFormat::ArtboardGroup(artboard_group) => artboard_group.artboards.into_iter().map(|(artboard, _)| TableRow::new_from_element(artboard)).collect(),

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

@@ -1,11 +1,11 @@
-use core_types::Color;
 use core_types::blending::AlphaBlending;
 use core_types::bounds::{BoundingBox, RenderBoundingBox};
 use core_types::graphene_hash::CacheHash;
 use core_types::ops::TableConvert;
 use core_types::render_complexity::RenderComplexity;
 use core_types::table::{Table, TableRow};
 use core_types::uuid::NodeId;
+use core_types::{ATTR_ALPHA_BLENDING, ATTR_EDITOR_LAYER_PATH, ATTR_TRANSFORM, Color};
 use dyn_any::DynAny;
 use glam::DAffine2;
 use raster_types::{CPU, GPU, Raster};
@@ -141,19 +141,19 @@ fn flatten_graphic_table<T>(content: Table<Graphic>, extract_variant: fn(Graphic
 
 	fn flatten_recursive<T>(output: &mut Table<T>, current_graphic_table: Table<Graphic>, extract_variant: fn(Graphic) -> Option<Table<T>>) {
 		for current_graphic_row in current_graphic_table.into_iter() {
-			let layer_path: Table<NodeId> = current_graphic_row.attribute_cloned_or_default("editor:layer");
-			let current_transform: DAffine2 = current_graphic_row.attribute_cloned_or_default("transform");
-			let current_alpha_blending: AlphaBlending = current_graphic_row.attribute_cloned_or_default("alpha_blending");
+			let layer_path: Table<NodeId> = current_graphic_row.attribute_cloned_or_default(ATTR_EDITOR_LAYER_PATH);
+			let current_transform: DAffine2 = current_graphic_row.attribute_cloned_or_default(ATTR_TRANSFORM);
+			let current_alpha_blending: AlphaBlending = current_graphic_row.attribute_cloned_or_default(ATTR_ALPHA_BLENDING);
 
 			match current_graphic_row.into_element() {
 				// Recurse into nested `Table<Graphic>` items, composing the parent's transform onto each child
 				Graphic::Graphic(mut sub_table) => {
 					for index in 0..sub_table.len() {
-						let child_transform: DAffine2 = sub_table.attribute_cloned_or_default("transform", index);
-						let child_alpha_blending: AlphaBlending = sub_table.attribute_cloned_or_default("alpha_blending", index);
+						let child_transform: DAffine2 = sub_table.attribute_cloned_or_default(ATTR_TRANSFORM, index);
+						let child_alpha_blending: AlphaBlending = sub_table.attribute_cloned_or_default(ATTR_ALPHA_BLENDING, index);
 
-						sub_table.set_attribute("transform", index, current_transform * child_transform);
-						sub_table.set_attribute("alpha_blending", index, compose_alpha_blending(current_alpha_blending, child_alpha_blending));
+						sub_table.set_attribute(ATTR_TRANSFORM, index, current_transform * child_transform);
+						sub_table.set_attribute(ATTR_ALPHA_BLENDING, index, compose_alpha_blending(current_alpha_blending, child_alpha_blending));
 					}
 
 					flatten_recursive(output, sub_table, extract_variant);
@@ -162,13 +162,13 @@ fn flatten_graphic_table<T>(content: Table<Graphic>, extract_variant: fn(Graphic
 				other => {
 					if let Some(typed_table) = extract_variant(other) {
 						for row in typed_table.into_iter() {
-							let row_transform: DAffine2 = row.attribute_cloned_or_default("transform");
-							let row_alpha_blending: AlphaBlending = row.attribute_cloned_or_default("alpha_blending");
+							let row_transform: DAffine2 = row.attribute_cloned_or_default(ATTR_TRANSFORM);
+							let row_alpha_blending: AlphaBlending = row.attribute_cloned_or_default(ATTR_ALPHA_BLENDING);
 							let (element, mut attributes) = row.into_parts();
 
-							attributes.insert("transform", current_transform * row_transform);
-							attributes.insert("alpha_blending", compose_alpha_blending(current_alpha_blending, row_alpha_blending));
-							attributes.insert("editor:layer", layer_path.clone());
+							attributes.insert(ATTR_TRANSFORM, current_transform * row_transform);
+							attributes.insert(ATTR_ALPHA_BLENDING, compose_alpha_blending(current_alpha_blending, row_alpha_blending));
+							attributes.insert(ATTR_EDITOR_LAYER_PATH, layer_path.clone());
 
 							output.push(TableRow::from_parts(element, attributes));
 						}
@@ -321,7 +321,7 @@ impl Graphic {
 
 	pub fn had_clip_enabled(&self) -> bool {
 		fn all_clipped<T>(table: &Table<T>) -> bool {
-			table.iter_attribute_values_or_default::<AlphaBlending>("alpha_blending").all(|a| a.clip)
+			table.iter_attribute_values_or_default::<AlphaBlending>(ATTR_ALPHA_BLENDING).all(|a| a.clip)
 		}
 		match self {
 			Graphic::Vector(table) => all_clipped(table),
@@ -337,7 +337,7 @@ impl Graphic {
 		match self {
 			Graphic::Vector(vector) => vector
 				.iter_element_values()
-				.zip(vector.iter_attribute_values_or_default::<AlphaBlending>("alpha_blending"))
+				.zip(vector.iter_attribute_values_or_default::<AlphaBlending>(ATTR_ALPHA_BLENDING))
 				.all(|(element, alpha_blending)| {
 					(alpha_blending.opacity > 1. - f32::EPSILON) && element.style.fill().is_opaque() && element.style.stroke().is_none_or(|stroke| !stroke.has_renderable_stroke())
 				}),
@@ -504,7 +504,7 @@ pub fn migrate_graphic<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Res
 		Table(serde_json::Value),
 	}
 
-	// Attributes (transform, alpha_blending, editor:layer) are not serialized, so migration only needs
+	// Attributes (transform, alpha_blending, editor:layer_path) are not serialized, so migration only needs
 	// to recover the elements. Per-item attribute values are populated at runtime by the node graph.
 	Ok(match GraphicFormat::deserialize(deserializer)? {
 		GraphicFormat::OldGraphicGroup(old) => old.elements.into_iter().map(|(graphic, _)| TableRow::new_from_element(graphic)).collect(),

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

@@ -72,7 +72,7 @@ pub mod migrations {
 
 		Ok(match VectorFormat::deserialize(deserializer)? {
 			VectorFormat::Vector(vector) => Table::new_from_element(vector),
-			// Attributes (transform, alpha_blending, editor:layer) are not serialized, so migration only needs
+			// Attributes (transform, alpha_blending, editor:layer_path) are not serialized, so migration only needs
 			// to recover the elements. Per-item attribute values are populated at runtime by the node graph.
 			VectorFormat::OldVectorData(old) => Table::new_from_element(Vector {
 				style: old.style,

node-graph/libraries/raster-types/src/image.rs

@@ -1,9 +1,8 @@
 use crate::raster_types::{CPU, Raster};
 use crate::{Bitmap, BitmapMut};
-use core_types::AlphaBlending;
-use core_types::Color;
 use core_types::color::float_to_srgb_u8;
 use core_types::table::{Table, TableRow};
+use core_types::{ATTR_ALPHA_BLENDING, ATTR_TRANSFORM, AlphaBlending, Color};
 // use crate::vector::Vector; // TODO: Check if Vector is actually used, if so handle differently
 use core_types::color::*;
 use dyn_any::{DynAny, StaticType};
@@ -319,7 +318,7 @@ pub fn migrate_image_frame<'de, D: serde::Deserializer<'de>>(deserializer: D) ->
 		Table::new_from_element(Raster::new_cpu(table.element(0).unwrap().clone()))
 	}
 
-	// Attributes (transform, alpha_blending, editor:layer) are not serialized, so migration only needs
+	// Attributes (transform, alpha_blending, editor:layer_path) are not serialized, so migration only needs
 	// to recover the elements. Per-item attribute values are populated at runtime by the node graph.
 	fn old_table_to_new_table<T>(old_table: OldTable<T>) -> Table<T> {
 		old_table.element.into_iter().map(TableRow::new_from_element).collect()
@@ -339,8 +338,8 @@ pub fn migrate_image_frame<'de, D: serde::Deserializer<'de>>(deserializer: D) ->
 		FormatVersions::Image(image) => Table::new_from_element(Raster::new_cpu(image)),
 		FormatVersions::OldImageFrame(OldImageFrame { image, transform, alpha_blending }) => {
 			let mut image_frame_table = Table::new_from_element(Raster::new_cpu(image));
-			image_frame_table.set_attribute("transform", 0, transform);
-			image_frame_table.set_attribute("alpha_blending", 0, alpha_blending);
+			image_frame_table.set_attribute(ATTR_TRANSFORM, 0, transform);
+			image_frame_table.set_attribute(ATTR_ALPHA_BLENDING, 0, alpha_blending);
 			image_frame_table
 		}
 		FormatVersions::OlderImageFrameTable(old_table) => from_image_frame_table(older_table_to_new_table(old_table)),
@@ -430,7 +429,7 @@ pub fn migrate_image_frame_row<'de, D: serde::Deserializer<'de>>(deserializer: D
 		RasterTableRow(TableRow<Raster<CPU>>),
 	}
 
-	// Attributes (transform, alpha_blending, editor:layer) are not serialized, so migration only needs
+	// Attributes (transform, alpha_blending, editor:layer_path) are not serialized, so migration only needs
 	// to recover the element. Per-item attribute values are populated at runtime by the node graph.
 	Ok(match FormatVersions::deserialize(deserializer)? {
 		FormatVersions::Image(image) => TableRow::new_from_element(Raster::new_cpu(image)),