Additional WASM translation layer cleanup

Author: Keavon

frontend/src/utilities/response-handler.ts

@@ -36,7 +36,6 @@ export function registerResponseHandler(responseType: ResponseType, callback: Re
 	state.responseMap[responseType] = callback;
 }
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function handleResponse(responseType: string, responseData: any) {
 	const callback = state.responseMap[responseType];
 	const data = parseResponse(responseType, responseData);
@@ -50,7 +49,6 @@ export function handleResponse(responseType: string, responseData: any) {
 	}
 }
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function parseResponse(responseType: string, data: any): Response {
 	switch (responseType) {
 		case "DocumentChanged":

frontend/wasm/src/document.rs

@@ -1,3 +1,4 @@
+use crate::dispatch;
 use crate::shims::Error;
 use crate::wrappers::{translate_key, translate_tool, Color};
 use editor::input::input_preprocessor::ModifierKeys;
@@ -9,20 +10,14 @@ use editor::LayerId;
 use graphene::layers::BlendMode;
 use wasm_bindgen::prelude::*;
 
-fn convert_error(err: editor::EditorError) -> JsValue {
-	Error::new(&err.to_string()).into()
-}
-
-fn dispatch<T: Into<Message>>(message: T) {
-	let messages = crate::EDITOR_STATE.with(|state| state.borrow_mut().handle_message(message.into()));
-	crate::handle_responses(messages);
-}
-
 /// Modify the currently selected tool in the document state store
 #[wasm_bindgen]
 pub fn select_tool(tool: String) -> Result<(), JsValue> {
 	match translate_tool(&tool) {
-		Some(tool) => Ok(dispatch(ToolMessage::ActivateTool(tool))),
+		Some(tool) => {
+			dispatch(ToolMessage::ActivateTool(tool));
+			Ok(())
+		}
 		None => Err(Error::new(&format!("Couldn't select {} because it was not recognized as a valid tool", tool)).into()),
 	}
 }
@@ -32,7 +27,10 @@ pub fn select_tool(tool: String) -> Result<(), JsValue> {
 pub fn set_tool_options(tool: String, options: &JsValue) -> Result<(), JsValue> {
 	match options.into_serde::<ToolOptions>() {
 		Ok(options) => match translate_tool(&tool) {
-			Some(tool) => Ok(dispatch(ToolMessage::SetToolOptions(tool, options))),
+			Some(tool) => {
+				dispatch(ToolMessage::SetToolOptions(tool, options));
+				Ok(())
+			}
 			None => Err(Error::new(&format!("Couldn't set options for {} because it was not recognized as a valid tool", tool)).into()),
 		},
 		Err(err) => Err(Error::new(&format!("Invalid JSON for ToolOptions: {}", err)).into()),
@@ -53,7 +51,10 @@ pub fn send_tool_message(tool: String, message: &JsValue) -> Result<(), JsValue>
 		None => Err(Error::new(&format!("Couldn't send message for {} because it was not recognized as a valid tool", tool)).into()),
 	};
 	match tool_message {
-		Ok(tool_message) => Ok(dispatch(tool_message)),
+		Ok(tool_message) => {
+			dispatch(tool_message);
+			Ok(())
+		}
 		Err(err) => Err(err),
 	}
 }
@@ -256,10 +257,11 @@ pub fn set_blend_mode_for_selected_layers(blend_mode_svg_style_name: String) ->
 		"saturation" => BlendMode::Saturation,
 		"color" => BlendMode::Color,
 		"luminosity" => BlendMode::Luminosity,
-		_ => return Err(convert_error(EditorError::Misc("UnknownBlendMode".to_string()))),
+		_ => return Err(Error::new(&EditorError::Misc("UnknownBlendMode".to_string()).to_string()).into()),
 	};
 
-	Ok(dispatch(DocumentMessage::SetBlendModeForSelectedLayers(blend_mode)))
+	dispatch(DocumentMessage::SetBlendModeForSelectedLayers(blend_mode));
+	Ok(())
 }
 
 /// Set the opacity for the selected layers

frontend/wasm/src/lib.rs

@@ -1,15 +1,14 @@
 pub mod document;
 mod shims;
 pub mod utils;
-pub mod window;
 pub mod wrappers;
 
 use editor::{message_prelude::*, Editor};
 use std::cell::RefCell;
 use utils::WasmLog;
 use wasm_bindgen::prelude::*;
 
-// the thread_local macro provides a way to initialize static variables with non-constant functions
+// The thread_local macro provides a way to initialize static variables with non-constant functions
 thread_local! {
 	pub static EDITOR_STATE: RefCell<Editor> = RefCell::new(Editor::new());
 }
@@ -22,24 +21,27 @@ pub fn init() {
 	log::set_max_level(log::LevelFilter::Debug);
 }
 
-pub fn handle_responses(responses: Vec<FrontendMessage>) {
-	for response in responses.into_iter() {
-		handle_response(response)
+// Sends FrontendMessages to JavaScript
+pub fn dispatch<T: Into<Message>>(message: T) {
+	let messages = EDITOR_STATE.with(|state| state.borrow_mut().handle_message(message.into()));
+
+	for message in messages.into_iter() {
+		let message_type = message.to_discriminant().local_name();
+		let message_data = JsValue::from_serde(&message).expect("Failed to serialize response");
+
+		let _ = handleResponse(message_type, message_data).map_err(|error| {
+			log::error!(
+				"While handling FrontendMessage \"{:?}\", JavaScript threw an error: {:?}",
+				message.to_discriminant().local_name(),
+				error
+			)
+		});
 	}
 }
 
+// The JavaScript function to call into
 #[wasm_bindgen(module = "/../src/utilities/response-handler-binding.ts")]
 extern "C" {
 	#[wasm_bindgen(catch)]
 	fn handleResponse(responseType: String, responseData: JsValue) -> Result<(), JsValue>;
 }
-
-fn handle_response(response: FrontendMessage) {
-	let response_type = response.to_discriminant().local_name();
-	send_response(response_type, response);
-}
-
-fn send_response(response_type: String, response_data: FrontendMessage) {
-	let response_data = JsValue::from_serde(&response_data).expect("Failed to serialize response");
-	let _ = handleResponse(response_type, response_data).map_err(|error| log::error!("javascript threw an error: {:?}", error));
-}

frontend/wasm/src/utils.rs

@@ -41,5 +41,6 @@ impl log::Log for WasmLog {
 		let msg = &format!("%c{}\t{}", name, record.args());
 		log(msg, color)
 	}
+
 	fn flush(&self) {}
 }