Rename Instances<T> to Table<T> and the "instance" terminology to "TableRow" and "element" (#2981)

* Instances -> Table

* instances.rs -> table.rs

* Rename occurrances of the word "instances"

* .instance -> .element

* Instance* -> TableRow*

* Rename Table and TableRow methods to not say "instance"

* Remove presumed unused serde defaults now that tables default to length 0 not 1

* Rename occurences of the word "instance"

* Un-alias the RasterDataTable<Storage>, VectorDataTable, GraphicGroupTable, ArtboardGroupTable typedefs

* Move artboard type and node code out of graphic_element.rs to a new artboard.rs

* Organize the TaggedValues

* Fix tests

* Fix prior regression with Image Value node not upgrading

node-graph/gstd/src/wasm_application_io.rs

@@ -2,15 +2,15 @@ use graph_craft::document::value::RenderOutput;
 pub use graph_craft::document::value::RenderOutputType;
 pub use graph_craft::wasm_application_io::*;
 use graphene_application_io::{ApplicationIo, ExportFormat, RenderConfig};
-#[cfg(target_family = "wasm")]
-use graphene_core::instances::Instances;
+use graphene_core::Artboard;
 #[cfg(target_family = "wasm")]
 use graphene_core::math::bbox::Bbox;
 use graphene_core::raster::image::Image;
-use graphene_core::raster_types::{CPU, Raster, RasterDataTable};
+use graphene_core::raster_types::{CPU, Raster};
+use graphene_core::table::Table;
 use graphene_core::transform::Footprint;
-use graphene_core::vector::VectorDataTable;
-use graphene_core::{Color, Context, Ctx, ExtractFootprint, GraphicGroupTable, OwnedContextImpl, WasmNotSend};
+use graphene_core::vector::VectorData;
+use graphene_core::{Color, Context, Ctx, ExtractFootprint, GraphicElement, OwnedContextImpl, WasmNotSend};
 use graphene_svg_renderer::RenderMetadata;
 use graphene_svg_renderer::{GraphicElementRendered, RenderParams, RenderSvgSegmentList, SvgRender, format_transform_matrix};
 
@@ -100,9 +100,9 @@ fn string_to_bytes(_: impl Ctx, string: String) -> Vec<u8> {
 }
 
 #[node_macro::node(category("Web Request"), name("Image to Bytes"))]
-fn image_to_bytes(_: impl Ctx, image: RasterDataTable<CPU>) -> Vec<u8> {
-	let Some(image) = image.instance_ref_iter().next() else { return vec![] };
-	image.instance.data.iter().flat_map(|color| color.to_rgb8_srgb().into_iter()).collect::<Vec<u8>>()
+fn image_to_bytes(_: impl Ctx, image: Table<Raster<CPU>>) -> Vec<u8> {
+	let Some(image) = image.iter_ref().next() else { return vec![] };
+	image.element.data.iter().flat_map(|color| color.to_rgb8_srgb().into_iter()).collect::<Vec<u8>>()
 }
 
 #[node_macro::node(category("Web Request"))]
@@ -121,9 +121,9 @@ async fn load_resource<'a: 'n>(_: impl Ctx, _primary: (), #[scope("editor-api")]
 }
 
 #[node_macro::node(category("Web Request"))]
-fn decode_image(_: impl Ctx, data: Arc<[u8]>) -> RasterDataTable<CPU> {
+fn decode_image(_: impl Ctx, data: Arc<[u8]>) -> Table<Raster<CPU>> {
 	let Some(image) = image::load_from_memory(data.as_ref()).ok() else {
-		return RasterDataTable::default();
+		return Table::new();
 	};
 	let image = image.to_rgba32f();
 	let image = Image {
@@ -136,7 +136,7 @@ fn decode_image(_: impl Ctx, data: Arc<[u8]>) -> RasterDataTable<CPU> {
 		..Default::default()
 	};
 
-	RasterDataTable::new(Raster::new_cpu(image))
+	Table::new_from_element(Raster::new_cpu(image))
 }
 
 fn render_svg(data: impl GraphicElementRendered, mut render: SvgRender, render_params: RenderParams, footprint: Footprint) -> RenderOutputType {
@@ -221,22 +221,22 @@ async fn render_canvas(
 async fn rasterize<T: WasmNotSend + 'n>(
 	_: impl Ctx,
 	#[implementations(
-		VectorDataTable,
-		RasterDataTable<CPU>,
-		GraphicGroupTable,
+		Table<VectorData>,
+		Table<Raster<CPU>>,
+		Table<GraphicElement>,
 	)]
-	mut data: Instances<T>,
+	mut data: Table<T>,
 	footprint: Footprint,
 	surface_handle: Arc<graphene_application_io::SurfaceHandle<HtmlCanvasElement>>,
-) -> RasterDataTable<CPU>
+) -> Table<Raster<CPU>>
 where
-	Instances<T>: GraphicElementRendered,
+	Table<T>: GraphicElementRendered,
 {
-	use graphene_core::instances::Instance;
+	use graphene_core::table::TableRow;
 
 	if footprint.transform.matrix2.determinant() == 0. {
 		log::trace!("Invalid footprint received for rasterization");
-		return RasterDataTable::default();
+		return Table::new();
 	}
 
 	let mut render = SvgRender::new();
@@ -249,8 +249,8 @@ where
 		..Default::default()
 	};
 
-	for instance in data.instance_mut_iter() {
-		*instance.transform = DAffine2::from_translation(-aabb.start) * *instance.transform;
+	for row in data.iter_mut() {
+		*row.transform = DAffine2::from_translation(-aabb.start) * *row.transform;
 	}
 	data.render_svg(&mut render, &render_params);
 	render.format_svg(glam::DVec2::ZERO, size);
@@ -277,8 +277,8 @@ where
 	let rasterized = context.get_image_data(0., 0., resolution.x as f64, resolution.y as f64).unwrap();
 
 	let image = Image::from_image_data(&rasterized.data().0, resolution.x as u32, resolution.y as u32);
-	RasterDataTable::new_instance(Instance {
-		instance: Raster::new_cpu(image),
+	Table::new_from_row(TableRow {
+		element: Raster::new_cpu(image),
 		transform: footprint.transform,
 		..Default::default()
 	})
@@ -289,11 +289,11 @@ async fn render<'a: 'n, T: 'n + GraphicElementRendered + WasmNotSend>(
 	render_config: RenderConfig,
 	editor_api: impl Node<Context<'static>, Output = &'a WasmEditorApi>,
 	#[implementations(
-		Context -> VectorDataTable,
-		Context -> RasterDataTable<CPU>,
-		Context -> GraphicGroupTable,
-		Context -> graphene_core::Artboard,
-		Context -> graphene_core::ArtboardGroupTable,
+		Context -> Table<VectorData>,
+		Context -> Table<Raster<CPU>>,
+		Context -> Table<GraphicElement>,
+		Context -> Table<Artboard>,
+		Context -> Artboard,
 		Context -> Option<Color>,
 		Context -> Vec<Color>,
 		Context -> bool,