fix response spelling

packages/fullstack/src/adapters/axum_adapter.rs

@@ -401,8 +401,8 @@ pub async fn server_fn_handler(
                                 .get("Accept")
                                 .and_then(|value| value.to_str().ok());
                             let mut res = Response::builder();
-                            *res.headers_mut().expect("empty responce should be valid") =
-                                server_context.take_responce_headers();
+                            *res.headers_mut().expect("empty response should be valid") =
+                                server_context.take_response_headers();
                             if accept_header == Some("application/json")
                                 || accept_header
                                     == Some(

packages/fullstack/src/adapters/salvo_adapter.rs

@@ -339,7 +339,7 @@ impl<P: Clone + serde::Serialize + Send + Sync + 'static> Handler for SSRHandler
         res.write_body(renderer_pool.render_vdom(&vdom, &self.cfg))
             .unwrap();
 
-        *res.headers_mut() = server_context.take_responce_headers();
+        *res.headers_mut() = server_context.take_response_headers();
     }
 }
 
@@ -408,7 +408,7 @@ impl ServerFnHandler {
         let result = resp_rx.await.unwrap();
 
         // Set the headers from the server context
-        *res.headers_mut() = server_context.take_responce_headers();
+        *res.headers_mut() = server_context.take_response_headers();
 
         match result {
             Ok(serialized) => {

packages/fullstack/src/adapters/warp_adapter.rs

@@ -196,7 +196,7 @@ pub fn render_ssr<P: Clone + serde::Serialize + Send + Sync + 'static>(
             let mut res = Response::builder();
 
             *res.headers_mut().expect("empty request should be valid") =
-                server_context.take_responce_headers();
+                server_context.take_response_headers();
 
             res.header("Content-Type", "text/html")
                 .body(Bytes::from(html))
@@ -289,7 +289,7 @@ pub async fn server_fn_handler(
                             let mut res = Response::builder();
 
                             *res.headers_mut().expect("empty request should be valid") =
-                                server_context.take_responce_headers();
+                                server_context.take_response_headers();
 
                             if accept_header == Some("application/json")
                                 || accept_header

packages/fullstack/src/server_context.rs

@@ -93,32 +93,32 @@ mod server_fn_impl {
         }
 
         /// Get the headers from the server context
-        pub fn responce_headers(&self) -> RwLockReadGuard<'_, hyper::header::HeaderMap> {
-            self.try_responce_headers()
+        pub fn response_headers(&self) -> RwLockReadGuard<'_, hyper::header::HeaderMap> {
+            self.try_response_headers()
                 .expect("Failed to get headers from server context")
         }
 
         /// Try to get the headers from the server context
-        pub fn try_responce_headers(
+        pub fn try_response_headers(
             &self,
         ) -> LockResult<RwLockReadGuard<'_, hyper::header::HeaderMap>> {
             self.headers.read()
         }
 
         /// Get the headers mutably from the server context
-        pub fn responce_headers_mut(&self) -> RwLockWriteGuard<'_, hyper::header::HeaderMap> {
-            self.try_responce_headers_mut()
+        pub fn response_headers_mut(&self) -> RwLockWriteGuard<'_, hyper::header::HeaderMap> {
+            self.try_response_headers_mut()
                 .expect("Failed to get headers mutably from server context")
         }
 
         /// Try to get the headers mut from the server context
-        pub fn try_responce_headers_mut(
+        pub fn try_response_headers_mut(
             &self,
         ) -> LockResult<RwLockWriteGuard<'_, hyper::header::HeaderMap>> {
             self.headers.write()
         }
 
-        pub(crate) fn take_responce_headers(&self) -> hyper::header::HeaderMap {
+        pub(crate) fn take_response_headers(&self) -> hyper::header::HeaderMap {
             let mut headers = self.headers.write().unwrap();
             std::mem::take(&mut *headers)
         }