htmxtools 0.1.4

A lightweight Rust crate for working with HTMX headers, specifically designed to integrate seamlessly with axum.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use std::{iter::once, ops::Deref};

#[cfg(feature = "axum")]
use axum_core::response::{IntoResponse, IntoResponseParts, Response, ResponseParts};
#[cfg(feature = "axum")]
use axum_extra::TypedHeader;
use headers_core::{Error, Header};
use http::{HeaderName, HeaderValue};

use crate::util::iter::IterExt;

use super::options::SwapOption;

static HX_RESWAP: HeaderName = HeaderName::from_static("hx-reswap");

/// Allows you to specify how the response will be swapped. See [`SwapOption`] for possible values.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct HxReswap(SwapOption);

impl HxReswap {
    /// Replace the inner html of the target element.
    pub const fn inner_html() -> Self {
        Self(SwapOption::InnerHtml)
    }

    /// Replace the entire target element with the response.
    pub const fn outer_html() -> Self {
        Self(SwapOption::OuterHtml)
    }

    /// Replace the text content of the target element, without parsing the response as HTML.
    pub const fn text_content() -> Self {
        Self(SwapOption::TextContent)
    }

    /// Insert the response before the target element.
    pub const fn before_begin() -> Self {
        Self(SwapOption::BeforeBegin)
    }

    /// Insert the response before the first child of the target element.
    pub const fn after_begin() -> Self {
        Self(SwapOption::AfterBegin)
    }

    /// Insert the response after the last child of the target element.
    pub const fn before_end() -> Self {
        Self(SwapOption::BeforeEnd)
    }

    /// Insert the response after the target element.
    pub const fn after_end() -> Self {
        Self(SwapOption::AfterEnd)
    }

    /// Deletes the target element regardless of the response.
    pub const fn delete() -> Self {
        Self(SwapOption::Delete)
    }

    /// Does not append content from response (out of band items will still be processed).
    pub const fn none() -> Self {
        Self(SwapOption::None)
    }

    /// Get the value of the `HxReswap`.
    pub fn swap_option(&self) -> SwapOption {
        self.0
    }
}

impl Deref for HxReswap {
    type Target = SwapOption;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl From<SwapOption> for HxReswap {
    fn from(swap_option: SwapOption) -> Self {
        Self(swap_option)
    }
}

impl From<HxReswap> for SwapOption {
    fn from(hx_reswap: HxReswap) -> Self {
        hx_reswap.0
    }
}

#[cfg(feature = "axum")]
#[cfg_attr(docsrs, doc(cfg(feature = "axum")))]
impl IntoResponseParts for HxReswap {
    type Error = <TypedHeader<Self> as IntoResponseParts>::Error;

    fn into_response_parts(self, res: ResponseParts) -> Result<ResponseParts, Self::Error> {
        TypedHeader(self).into_response_parts(res)
    }
}

#[cfg(feature = "axum")]
#[cfg_attr(docsrs, doc(cfg(feature = "axum")))]
impl IntoResponse for HxReswap {
    fn into_response(self) -> Response {
        TypedHeader(self).into_response()
    }
}

impl Header for HxReswap {
    fn name() -> &'static HeaderName {
        &HX_RESWAP
    }

    fn decode<'i, I>(values: &mut I) -> Result<Self, Error>
    where
        Self: Sized,
        I: Iterator<Item = &'i HeaderValue>,
    {
        let value = values.just_one().ok_or_else(Error::invalid)?;
        let swap_option = SwapOption::from_header_value(value)?;

        Ok(Self(swap_option))
    }

    fn encode<E: Extend<HeaderValue>>(&self, values: &mut E) {
        values.extend(once(self.0.to_header_value()));
    }
}