neon/types_impl/
date.rs

1use std::{
2    error::Error,
3    fmt::{self, Debug},
4};
5
6use super::{private::ValueInternal, Value};
7
8use crate::{
9    context::{
10        internal::{ContextInternal, Env},
11        Context, Cx,
12    },
13    handle::{internal::TransparentNoCopyWrapper, Handle},
14    object::Object,
15    result::{JsResult, ResultExt},
16    sys::{self, raw},
17};
18
19/// The type of JavaScript
20/// [`Date`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date)
21/// objects.
22///
23/// # Example
24///
25/// The following shows an example of converting Rust
26/// [`SystemTime`](std::time::SystemTime) timestamps to JavaScript `Date` objects.
27///
28/// ```
29/// # use neon::prelude::*;
30/// use easy_cast::Cast; // for safe numeric conversions
31/// use neon::types::JsDate;
32/// use std::{error::Error, fs::File, time::SystemTime};
33///
34/// /// Return the "modified" timestamp for the file at the given path.
35/// fn last_modified(path: &str) -> Result<f64, Box<dyn Error>> {
36///     Ok(File::open(&path)?
37///         .metadata()?
38///         .modified()?
39///         .duration_since(SystemTime::UNIX_EPOCH)?
40///         .as_millis()
41///         .try_cast()?)
42/// }
43///
44/// fn modified(mut cx: FunctionContext) -> JsResult<JsDate> {
45///     let path: Handle<JsString> = cx.argument(0)?;
46///
47///     last_modified(&path.value(&mut cx))
48///         .and_then(|n| Ok(cx.date(n)?))
49///         .or_else(|err| cx.throw_error(err.to_string()))
50/// }
51/// ```
52#[cfg_attr(docsrs, doc(cfg(feature = "napi-5")))]
53#[derive(Debug)]
54#[repr(transparent)]
55pub struct JsDate(raw::Local);
56
57impl Value for JsDate {}
58
59unsafe impl TransparentNoCopyWrapper for JsDate {
60    type Inner = raw::Local;
61
62    fn into_inner(self) -> Self::Inner {
63        self.0
64    }
65}
66
67/// An error produced when constructing a date with an invalid value.
68#[derive(Debug)]
69#[cfg_attr(docsrs, doc(cfg(feature = "napi-5")))]
70pub struct DateError(DateErrorKind);
71
72impl DateError {
73    pub fn kind(&self) -> DateErrorKind {
74        self.0
75    }
76}
77
78impl fmt::Display for DateError {
79    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
80        fmt.write_str(self.0.as_str())
81    }
82}
83
84impl Error for DateError {}
85
86/// The error kinds corresponding to `DateError`
87#[derive(Debug, Copy, Clone, PartialEq, Eq)]
88#[cfg_attr(docsrs, doc(cfg(feature = "napi-5")))]
89pub enum DateErrorKind {
90    /// Produced for an initialization value greater than
91    /// [`JsDate::MAX_VALUE`](JsDate::MAX_VALUE).
92    Overflow,
93    /// Produced for an initialization value lesser than
94    /// [`JsDate::MIN_VALUE`](JsDate::MIN_VALUE).
95    Underflow,
96}
97
98impl DateErrorKind {
99    fn as_str(&self) -> &'static str {
100        match *self {
101            DateErrorKind::Overflow => "Date overflow",
102            DateErrorKind::Underflow => "Date underflow",
103        }
104    }
105}
106
107impl<'a, T: Value> ResultExt<Handle<'a, T>> for Result<Handle<'a, T>, DateError> {
108    /// Creates an `Error` on error
109    fn or_throw<'b, C: Context<'b>>(self, cx: &mut C) -> JsResult<'a, T> {
110        self.or_else(|e| cx.throw_range_error(e.0.as_str()))
111    }
112}
113
114impl JsDate {
115    /// The smallest possible `Date` value,
116    /// [defined by ECMAScript](https://www.ecma-international.org/ecma-262/5.1/#sec-15.7.3.3).
117    pub const MIN_VALUE: f64 = -8.64e15;
118    /// The largest possible `Date` value,
119    /// [defined by ECMAScript](https://www.ecma-international.org/ecma-262/5.1/#sec-15.7.3.2).
120    pub const MAX_VALUE: f64 = 8.64e15;
121
122    /// Creates a new `Date`. It errors when `value` is outside the range of valid JavaScript
123    /// `Date` values. When `value` is `NaN`, the operation will succeed but with an
124    /// invalid `Date`.
125    pub fn new<'a, C: Context<'a>, T: Into<f64>>(
126        cx: &mut C,
127        value: T,
128    ) -> Result<Handle<'a, JsDate>, DateError> {
129        let env = cx.env().to_raw();
130        let time = value.into();
131
132        if time > JsDate::MAX_VALUE {
133            return Err(DateError(DateErrorKind::Overflow));
134        } else if time < JsDate::MIN_VALUE {
135            return Err(DateError(DateErrorKind::Underflow));
136        }
137
138        let local = unsafe { sys::date::new_date(env, time) };
139        let date = Handle::new_internal(JsDate(local));
140        Ok(date)
141    }
142
143    /// Creates a new `Date` with lossy conversion for out of bounds `Date` values.
144    /// Out of bounds values will be treated as `NaN`.
145    pub fn new_lossy<'a, C: Context<'a>, V: Into<f64>>(cx: &mut C, value: V) -> Handle<'a, JsDate> {
146        let env = cx.env().to_raw();
147        let local = unsafe { sys::date::new_date(env, value.into()) };
148        Handle::new_internal(JsDate(local))
149    }
150
151    /// Gets the `Date`'s value. An invalid `Date` will return [`std::f64::NAN`].
152    pub fn value<'a, C: Context<'a>>(&self, cx: &mut C) -> f64 {
153        let env = cx.env().to_raw();
154        unsafe { sys::date::value(env, self.to_local()) }
155    }
156
157    /// Checks if the `Date`'s value is valid. A `Date` is valid if its value is
158    /// between [`JsDate::MIN_VALUE`] and [`JsDate::MAX_VALUE`] or if it is `NaN`.
159    pub fn is_valid<'a, C: Context<'a>>(&self, cx: &mut C) -> bool {
160        let value = self.value(cx);
161        (JsDate::MIN_VALUE..=JsDate::MAX_VALUE).contains(&value)
162    }
163}
164
165impl ValueInternal for JsDate {
166    fn name() -> &'static str {
167        "object"
168    }
169
170    fn is_typeof<Other: Value>(cx: &mut Cx, other: &Other) -> bool {
171        unsafe { sys::tag::is_date(cx.env().to_raw(), other.to_local()) }
172    }
173
174    fn to_local(&self) -> raw::Local {
175        self.0
176    }
177
178    unsafe fn from_local(_env: Env, h: raw::Local) -> Self {
179        JsDate(h)
180    }
181}
182
183impl Object for JsDate {}
neon/types_impl/date.rs

neon/types_impl/
date.rs
