use-js-value 0.0.1

JavaScript-like primitive value metadata for RustUse
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

#![forbid(unsafe_code)]
#![doc = include_str!("../README.md")]

/// Primitive JavaScript-like values for metadata and validation helpers.
#[derive(Clone, Debug, PartialEq)]
pub enum JsPrimitiveValue {
    Undefined,
    Null,
    Boolean(bool),
    Number(f64),
    String(String),
    BigInt(String),
    Symbol(String),
}

impl JsPrimitiveValue {
    /// Returns a JavaScript-style primitive type label.
    #[must_use]
    pub const fn type_name(&self) -> &'static str {
        match self {
            Self::Undefined => "undefined",
            Self::Null => "null",
            Self::Boolean(_) => "boolean",
            Self::Number(_) => "number",
            Self::String(_) => "string",
            Self::BigInt(_) => "bigint",
            Self::Symbol(_) => "symbol",
        }
    }

    /// Returns whether the value is approximately truthy by JavaScript primitive rules.
    #[must_use]
    pub fn is_truthy_like(&self) -> bool {
        match self {
            Self::Undefined | Self::Null => false,
            Self::Boolean(value) => *value,
            Self::Number(value) => *value != 0.0 && !value.is_nan(),
            Self::String(value) => !value.is_empty(),
            Self::BigInt(value) => !matches!(value.as_str(), "0" | "-0"),
            Self::Symbol(_) => true,
        }
    }

    /// Returns whether the value is `null` or `undefined`.
    #[must_use]
    pub const fn is_nullish(&self) -> bool {
        matches!(self, Self::Undefined | Self::Null)
    }
}

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

    #[test]
    fn reports_type_names() {
        assert_eq!(JsPrimitiveValue::Undefined.type_name(), "undefined");
        assert_eq!(
            JsPrimitiveValue::BigInt(String::from("1")).type_name(),
            "bigint"
        );
    }

    #[test]
    fn checks_nullish_and_truthy_values() {
        assert!(JsPrimitiveValue::Null.is_nullish());
        assert!(!JsPrimitiveValue::Number(0.0).is_truthy_like());
        assert!(!JsPrimitiveValue::Number(f64::NAN).is_truthy_like());
        assert!(JsPrimitiveValue::String(String::from("x")).is_truthy_like());
        assert!(JsPrimitiveValue::Symbol(String::new()).is_truthy_like());
    }
}