refactor(alias): new fn

src/nodes/alias.rs

@@ -1,35 +1,38 @@
+use crate::core::client::Client;
+
 use super::Node;
 use std::sync::{Arc, Weak};
 
+#[derive(Debug, Default, Clone)]
+pub struct AliasInfo {
+	pub(super) local_signals: Vec<&'static str>,
+	pub(super) local_methods: Vec<&'static str>,
+	pub(super) remote_signals: Vec<&'static str>,
+}
+
 #[allow(dead_code)]
 pub struct Alias {
 	pub(super) node: Weak<Node>,
 	pub original: Weak<Node>,
 
-	pub(super) local_signals: Vec<&'static str>,
+	pub info: AliasInfo,
-	pub(super) local_methods: Vec<&'static str>,
-	pub(super) remote_signals: Vec<&'static str>,
-	pub(super) remote_methods: Vec<&'static str>,
 }
 impl Alias {
-	pub fn add_to(
+	pub fn new(
-		node: &Arc<Node>,
+		client: &Arc<Client>,
+		parent: &str,
+		name: &str,
 		original: &Arc<Node>,
-		local_signals: Vec<&'static str>,
+		info: AliasInfo,
-		local_methods: Vec<&'static str>,
+	) -> Arc<Node> {
-		remote_signals: Vec<&'static str>,
+		let node = Node::create(client, parent, name, true).add_to_scenegraph();
-		remote_methods: Vec<&'static str>,
-	) -> Arc<Alias> {
 		let alias = Alias {
-			node: Arc::downgrade(node),
+			node: Arc::downgrade(&node),
 			original: Arc::downgrade(original),
-			local_signals,
+			info,
-			local_methods,
-			remote_signals,
-			remote_methods,
 		};
 		let alias = original.aliases.add(alias);
-		let _ = node.alias.set(alias.clone());
+		let _ = node.alias.set(alias);
-		alias
+		node
 	}
 }

src/nodes/data.rs

@@ -1,3 +1,4 @@
+use super::alias::AliasInfo;
 use super::fields::Field;
 use super::spatial::{parse_transform, Spatial};
 use super::{Alias, Node};
@@ -128,20 +129,15 @@ impl PulseSender {
 		let uids: Vec<String> = distance_sorted_receivers
 			.into_iter()
 			.map(|(_, receiver)| {
-				let receiver_alias = Node::create(
+				let receiver_alias = Alias::new(
 					&calling_client,
 					node.get_path(),
 					receiver.uid.as_str(),
-					false,
-				)
-				.add_to_scenegraph();
-				Alias::add_to(
-					&receiver_alias,
 					receiver.node.upgrade().as_ref().unwrap(),
-					vec![],
+					AliasInfo {
-					vec!["sendData"],
+						local_methods: vec!["sendData"],
-					vec![],
+						..Default::default()
-					vec![],
+					},
 				);
 				sender.aliases.add(Arc::downgrade(&receiver_alias));
 

src/nodes/hmd.rs

@@ -1,5 +1,8 @@
 use super::{alias::Alias, spatial::Spatial, Node};
-use crate::core::client::{Client, INTERNAL_CLIENT};
+use crate::{
+	core::client::{Client, INTERNAL_CLIENT},
+	nodes::alias::AliasInfo,
+};
 use glam::{vec3, Mat4};
 use std::sync::Arc;
 use stereokit::StereoKit;
@@ -26,7 +29,14 @@ pub fn frame(sk: &StereoKit) {
 }
 
 pub fn make_alias(client: &Arc<Client>) -> Arc<Node> {
-	let node = Node::create(client, "", "hmd", false).add_to_scenegraph();
+	Alias::new(
-	Alias::add_to(&node, &HMD, vec!["getTransform"], vec![], vec![], vec![]);
+		client,
-	node
+		"",
+		"hmd",
+		&HMD,
+		AliasInfo {
+			local_signals: vec!["getTransform"],
+			..Default::default()
+		},
+	)
 }

src/nodes/items/mod.rs

@@ -7,6 +7,7 @@ use super::{Alias, Node};
 use crate::core::client::{Client, INTERNAL_CLIENT};
 use crate::core::nodelist::LifeLinkedNodeList;
 use crate::core::registry::Registry;
+use crate::nodes::alias::AliasInfo;
 use crate::nodes::fields::find_field;
 use crate::wayland::panel_item::{register_panel_item_ui_flex, PanelItem};
 use anyhow::{anyhow, ensure, Result};
@@ -120,31 +121,30 @@ impl Item {
 		item
 	}
 	fn make_alias(&self, client: &Arc<Client>, parent: &str) -> (Arc<Node>, Arc<Alias>) {
-		let node = Node::create(client, parent, &self.uid, true).add_to_scenegraph();
+		let node = Alias::new(
-		let alias = Alias::add_to(
+			client,
-			&node,
+			parent,
+			&self.uid,
 			&self.node.upgrade().unwrap(),
-			[
+			AliasInfo {
-				&self.type_info.aliased_local_signals,
+				local_signals: [
-				ITEM_ALIAS_LOCAL_SIGNALS.as_slice(),
+					&self.type_info.aliased_local_signals,
-			]
+					ITEM_ALIAS_LOCAL_SIGNALS.as_slice(),
-			.concat(),
+				]
-			[
+				.concat(),
-				&self.type_info.aliased_local_methods,
+				local_methods: [
-				ITEM_ALIAS_LOCAL_METHODS.as_slice(),
+					&self.type_info.aliased_local_methods,
-			]
+					ITEM_ALIAS_LOCAL_METHODS.as_slice(),
-			.concat(),
+				]
-			[
+				.concat(),
-				&self.type_info.aliased_remote_signals,
+				remote_signals: [
-				ITEM_ALIAS_REMOTE_SIGNALS.as_slice(),
+					&self.type_info.aliased_remote_signals,
-			]
+					ITEM_ALIAS_REMOTE_SIGNALS.as_slice(),
-			.concat(),
+				]
-			[
+				.concat(),
-				&self.type_info.aliased_remote_methods,
+			},
-				ITEM_ALIAS_REMOTE_METHODS.as_slice(),
-			]
-			.concat(),
 		);
+		let alias = node.alias.get().unwrap().clone();
 		(node, alias)
 	}
 }
@@ -273,27 +273,25 @@ impl ItemAcceptor {
 	fn make_aliases(&self, client: &Arc<Client>, parent: &str) -> Vec<Arc<Node>> {
 		let mut aliases = Vec::new();
 		let acceptor_node = &self.node.upgrade().unwrap();
-		let acceptor_alias =
+		let acceptor_alias = Alias::new(
-			Node::create(client, parent, acceptor_node.uid.as_str(), true).add_to_scenegraph();
+			client,
-		Alias::add_to(
+			parent,
-			&acceptor_alias,
+			acceptor_node.uid.as_str(),
 			acceptor_node,
-			vec!["release"],
+			AliasInfo {
-			vec![],
+				local_signals: vec!["release"],
-			vec![],
+				..Default::default()
-			vec![],
+			},
 		);
 		if let Some(field) = self.field.lock().upgrade() {
-			let acceptor_field_alias =
+			let acceptor_field_alias = Alias::new(
-				Node::create(client, acceptor_alias.get_path(), "field", true).add_to_scenegraph();
+				client,
-			Alias::add_to(
+				acceptor_alias.get_path(),
-				&acceptor_field_alias,
+				"field",
 				&field.spatial_ref().node.upgrade().unwrap(),
-				vec![],
+				AliasInfo::default(),
-				vec![],
-				vec![],
-				vec![],
 			);
+
 			aliases.push(acceptor_field_alias);
 		}
 		aliases.push(acceptor_alias);

src/nodes/mod.rs

@@ -167,7 +167,7 @@ impl Node {
 		data: &[u8],
 	) -> Result<(), ScenegraphError> {
 		if let Some(alias) = self.alias.get() {
-			if !alias.local_signals.iter().any(|e| e == &method) {
+			if !alias.info.local_signals.iter().any(|e| e == &method) {
 				return Err(ScenegraphError::SignalNotFound);
 			}
 			alias
@@ -191,7 +191,7 @@ impl Node {
 		data: &[u8],
 	) -> Result<Vec<u8>, ScenegraphError> {
 		if let Some(alias) = self.alias.get() {
-			if !alias.local_methods.iter().any(|e| e == &method) {
+			if !alias.info.local_methods.iter().any(|e| e == &method) {
 				return Err(ScenegraphError::MethodNotFound);
 			}
 			alias
@@ -212,7 +212,7 @@ impl Node {
 		self.aliases
 			.get_valid_contents()
 			.iter()
-			.filter(|alias| alias.remote_signals.iter().any(|e| e == &method))
+			.filter(|alias| alias.info.remote_signals.iter().any(|e| e == &method))
 			.for_each(|alias| {
 				let _ = alias
 					.node

src/nodes/spatial.rs

@@ -283,7 +283,7 @@ pub fn create_spatial_flex(_node: &Node, calling_client: Arc<Client>, data: &[u8
 	}
 	let info: CreateSpatialInfo = deserialize(data)?;
 	let node = Node::create(&calling_client, "/spatial/spatial", info.name, true);
-	let parent = find_spatial(&calling_client, "Spatial parent", info.parent_path)?;
+	let parent = find_spatial_parent(&calling_client, info.parent_path)?;
 	let transform = parse_transform(info.transform, true, true, true)?;
 	let node = node.add_to_scenegraph();
 	Spatial::add_to(&node, Some(parent), transform)?;