datastar 0.4.0

//! Datastar constants
#![allow(rustdoc::invalid_html_tags)]

// Keep these values synchronized with Datastar's SDK configuration.

#[expect(unused)]
pub(crate) const DATASTAR_KEY: &str = "datastar";
#[allow(unused)]
pub(crate) const DATASTAR_REQ_HEADER_STR: &str = "datastar-request";

// #region Defaults

// #region Default durations

/// The default duration for retrying SSE on connection reset. This is part of the underlying retry mechanism of SSE.
pub const DEFAULT_SSE_RETRY_DURATION: u64 = 1000;

// #endregion

// #region Default strings

// #endregion

// #region Datalines

pub(crate) const SELECTOR_DATALINE_LITERAL: &str = "selector";
pub(crate) const MODE_DATALINE_LITERAL: &str = "mode";
pub(crate) const ELEMENTS_DATALINE_LITERAL: &str = "elements";
pub(crate) const USE_VIEW_TRANSITION_DATALINE_LITERAL: &str = "useViewTransition";
pub(crate) const VIEW_TRANSITION_SELECTOR_DATALINE_LITERAL: &str = "viewTransitionSelector";
pub(crate) const NAMESPACE_DATALINE_LITERAL: &str = "namespace";
pub(crate) const SIGNALS_DATALINE_LITERAL: &str = "signals";
pub(crate) const ONLY_IF_MISSING_DATALINE_LITERAL: &str = "onlyIfMissing";

// #endregion

// #region Default booleans

/// Should elements be patched using the ViewTransition API?
pub(crate) const DEFAULT_ELEMENTS_USE_VIEW_TRANSITIONS: bool = false;
/// Should a given set of signals patch if they are missing?
pub(crate) const DEFAULT_PATCH_SIGNALS_ONLY_IF_MISSING: bool = false;

// #endregion

// #region Enums

/// The mode in which an element is patched into the DOM.
#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum ElementPatchMode {
    /// Morphs the element into the existing element.
    #[default]
    Outer,
    /// Replaces the inner HTML of the existing element.
    Inner,
    /// Removes the existing element.
    Remove,
    /// Replaces the existing element with the new element.
    Replace,
    /// Prepends the element inside to the existing element.
    Prepend,
    /// Appends the element inside the existing element.
    Append,
    /// Inserts the element before the existing element.
    Before,
    /// Inserts the element after the existing element.
    After,
}

impl ElementPatchMode {
    /// Returns the [`ElementPatchMode`] as a [`&'static str`].
    pub(crate) const fn as_str(&self) -> &'static str {
        match self {
            Self::Outer => "outer",
            Self::Inner => "inner",
            Self::Remove => "remove",
            Self::Replace => "replace",
            Self::Prepend => "prepend",
            Self::Append => "append",
            Self::Before => "before",
            Self::After => "after",
        }
    }
}

/// The type protocol on top of SSE which allows for core pushed based communication between the server and the client.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum EventType {
    /// An event for patching HTML elements into the DOM.
    PatchElements,
    /// An event for patching signals.
    PatchSignals,
}

impl EventType {
    /// Returns the [`EventType`] as a string.
    pub(crate) const fn as_str(&self) -> &str {
        match self {
            Self::PatchElements => "datastar-patch-elements",
            Self::PatchSignals => "datastar-patch-signals",
        }
    }
}

/// The namespace in which elements are created.
#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Namespace {
    /// HTML namespace for standard HTML elements.
    #[default]
    Html,
    /// SVG namespace for SVG elements.
    Svg,
    /// MathML namespace for mathematical notation.
    MathMl,
}

impl Namespace {
    /// Returns the [`Namespace`] as a [`&'static str`].
    pub(crate) const fn as_str(&self) -> &'static str {
        match self {
            Self::Html => "html",
            Self::Svg => "svg",
            Self::MathMl => "mathml",
        }
    }
}
// #endregion

// #endregion

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn maps_element_patch_modes() {
        assert_eq!(ElementPatchMode::Outer.as_str(), "outer");
        assert_eq!(ElementPatchMode::Inner.as_str(), "inner");
        assert_eq!(ElementPatchMode::Remove.as_str(), "remove");
        assert_eq!(ElementPatchMode::Replace.as_str(), "replace");
        assert_eq!(ElementPatchMode::Prepend.as_str(), "prepend");
        assert_eq!(ElementPatchMode::Append.as_str(), "append");
        assert_eq!(ElementPatchMode::Before.as_str(), "before");
        assert_eq!(ElementPatchMode::After.as_str(), "after");
    }

    #[test]
    fn maps_event_types() {
        assert_eq!(EventType::PatchElements.as_str(), "datastar-patch-elements");
        assert_eq!(EventType::PatchSignals.as_str(), "datastar-patch-signals");
    }

    #[test]
    fn maps_namespaces() {
        assert_eq!(Namespace::Html.as_str(), "html");
        assert_eq!(Namespace::Svg.as_str(), "svg");
        assert_eq!(Namespace::MathMl.as_str(), "mathml");
    }
}