From a75748bff93d2bd324dcb87f3d4579952da9f33d Mon Sep 17 00:00:00 2001 From: pjh456 <147148383@qq.com> Date: Sat, 27 Jun 2026 19:03:46 +0800 Subject: [PATCH] =?UTF-8?q?feat:=20Date=20=E6=97=B6=E5=8C=BA=E4=BF=AE?= =?UTF-8?q?=E5=A4=8D=20+=20setUTC*=20=E6=96=B9=E6=B3=95=20+=20Date.UTC=20?= =?UTF-8?q?=E5=AE=9E=E7=8E=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- crates/oxide_builtins/src/date.rs | 350 ++++++++++++++++--- crates/oxide_vm/src/bindings/bind_date.rs | 57 +++ crates/oxide_vm/tests/builtins_date_tests.rs | 194 +++++++++- 3 files changed, 557 insertions(+), 44 deletions(-) diff --git a/crates/oxide_builtins/src/date.rs b/crates/oxide_builtins/src/date.rs index e130ac42..b6b63fcb 100644 --- a/crates/oxide_builtins/src/date.rs +++ b/crates/oxide_builtins/src/date.rs @@ -1,4 +1,4 @@ -use chrono::{DateTime, Datelike, NaiveDate, NaiveDateTime, Timelike, Utc}; +use chrono::{DateTime, Datelike, Local, NaiveDate, NaiveDateTime, Timelike, Utc}; use oxide_kernel::shape_forge::EMPTY_SHAPE_ID; use oxide_types::object::JsObject; @@ -70,6 +70,13 @@ fn dt_from_ms(ms: f64) -> Option> { DateTime::from_timestamp_millis(ms as i64) } +fn dt_from_ms_local(ms: f64) -> Option> { + if !ms.is_finite() { + return None; + } + DateTime::from_timestamp_millis(ms as i64).map(|dt| dt.with_timezone(&Local)) +} + fn naive_from_ms(ms: f64) -> Option { if !ms.is_finite() { return None; @@ -102,40 +109,47 @@ pub fn date_constructor(vm: &mut H, args: &[u8]) -> NativeResult { let timestamp = if args.len() < 2 { Utc::now().timestamp_millis() as f64 } else if args.len() > 2 { - let y = vm.coerce_number_bounded(vm.reg(args[1])).unwrap_or(f64::NAN) as i32; - let m = vm.coerce_number_bounded(vm.reg(args[2])).unwrap_or(f64::NAN) as u32; - let d = if args.len() > 3 { - vm.coerce_number_bounded(vm.reg(args[3])).unwrap_or(f64::NAN) as u32 + let now = chrono::Local::now(); + let y_val = oxide_runtime_api::to_number(vm.reg(args[1])); + let m_val = oxide_runtime_api::to_number(vm.reg(args[2])); + if y_val.is_nan() || m_val.is_nan() { + f64::NAN } else { - 1 + let y = y_val.trunc() as i32; + let m = m_val.trunc() as u32; + let d = if args.len() > 3 { + oxide_runtime_api::to_number(vm.reg(args[3])).trunc() as u32 + } else { + now.day() }; let h = if args.len() > 4 { - vm.coerce_number_bounded(vm.reg(args[4])).unwrap_or(f64::NAN) as u32 + oxide_runtime_api::to_number(vm.reg(args[4])).trunc() as u32 } else { - 0 + now.hour() }; let min = if args.len() > 5 { - vm.coerce_number_bounded(vm.reg(args[5])).unwrap_or(f64::NAN) as u32 + oxide_runtime_api::to_number(vm.reg(args[5])).trunc() as u32 } else { - 0 + now.minute() }; let sec = if args.len() > 6 { - vm.coerce_number_bounded(vm.reg(args[6])).unwrap_or(f64::NAN) as u32 + oxide_runtime_api::to_number(vm.reg(args[6])).trunc() as u32 } else { - 0 + now.second() }; let ms = if args.len() > 7 { - vm.coerce_number_bounded(vm.reg(args[7])).unwrap_or(f64::NAN) as u32 + oxide_runtime_api::to_number(vm.reg(args[7])).trunc() as u32 } else { - 0 + now.timestamp_subsec_millis() }; NaiveDate::from_ymd_opt(y, m + 1, d) .and_then(|nd| { nd.and_hms_milli_opt(h, min, sec, ms) - .and_then(|ndt| ndt.and_local_timezone(Utc).earliest()) + .and_then(|ndt| ndt.and_local_timezone(Local).earliest()) }) .map(|dt| dt.timestamp_millis() as f64) .unwrap_or(f64::NAN) + } } else { let val = vm.reg(args[1]); if val.is_string() { @@ -214,12 +228,22 @@ pub fn date_parse(vm: &mut H, args: &[u8]) -> NativeResult { } // SAFETY: val is a string value. let s = unsafe { (*val.as_string_ptr()).data.clone() }; - let formats = ["%Y-%m-%dT%H:%M:%S%.fZ", "%Y-%m-%dT%H:%M:%S%.f"]; let mut ts = f64::NAN; - for fmt in &formats { - if let Ok(ndt) = NaiveDateTime::parse_from_str(&s, fmt) { - ts = ndt.and_utc().timestamp_millis() as f64; - break; + if let Ok(dt) = chrono::DateTime::parse_from_rfc2822(&s) { + ts = dt.timestamp_millis() as f64; + } + if ts.is_nan() { + let formats = [ + "%Y-%m-%dT%H:%M:%S%.fZ", + "%Y-%m-%dT%H:%M:%S%.f", + "%Y-%m-%dT%H:%M:%S%.f%:z", + "%Y-%m-%dT%H:%M:%S%.f%#z", + ]; + for fmt in &formats { + if let Ok(ndt) = NaiveDateTime::parse_from_str(&s, fmt) { + ts = ndt.and_utc().timestamp_millis() as f64; + break; + } } } if ts.is_nan() { @@ -229,11 +253,38 @@ pub fn date_parse(vm: &mut H, args: &[u8]) -> NativeResult { } } } + if ts.is_nan() { + if let Ok(nd) = NaiveDate::parse_from_str(&s, "%Y/%m/%d") { + if let Some(ndt) = nd.and_hms_opt(0, 0, 0).and_then(|n| n.and_local_timezone(Utc).earliest()) { + ts = ndt.timestamp_millis() as f64; + } + } + } NativeResult::Ok(JsValue::float(ts)) } -pub fn date_utc(_vm: &mut H, _args: &[u8]) -> NativeResult { - NativeResult::Ok(JsValue::float(f64::NAN)) +pub fn date_utc(vm: &mut H, args: &[u8]) -> NativeResult { + if args.len() < 3 { + return NativeResult::Ok(JsValue::float(f64::NAN)); + } + let y = oxide_runtime_api::to_number(vm.reg(args[1])); + let m = oxide_runtime_api::to_number(vm.reg(args[2])); + if y.is_nan() || m.is_nan() { + return NativeResult::Ok(JsValue::float(f64::NAN)); + } + let y = y.trunc() as i32; + let m = m.trunc() as u32; + let d = if args.len() > 3 { oxide_runtime_api::to_number(vm.reg(args[3])).trunc() as u32 } else { 1 }; + let h = if args.len() > 4 { oxide_runtime_api::to_number(vm.reg(args[4])).trunc() as u32 } else { 0 }; + let min = if args.len() > 5 { oxide_runtime_api::to_number(vm.reg(args[5])).trunc() as u32 } else { 0 }; + let sec = if args.len() > 6 { oxide_runtime_api::to_number(vm.reg(args[6])).trunc() as u32 } else { 0 }; + let ms = if args.len() > 7 { oxide_runtime_api::to_number(vm.reg(args[7])).trunc() as u32 } else { 0 }; + let ts = NaiveDate::from_ymd_opt(y, m + 1, d) + .and_then(|nd| nd.and_hms_milli_opt(h, min, sec, ms)) + .and_then(|ndt| ndt.and_local_timezone(Utc).earliest()) + .map(|dt| dt.timestamp_millis() as f64) + .unwrap_or(f64::NAN); + NativeResult::Ok(JsValue::float(ts)) } macro_rules! make_getter { @@ -268,15 +319,31 @@ macro_rules! make_utc_getter { }; } +macro_rules! make_local_getter { + ($name:ident, $f:expr, $df:expr) => { + pub fn $name(vm: &mut H, args: &[u8]) -> NativeResult { + let obj = unsafe { &*native_try!(date_this(vm, args)) }; + let ms = get_timestamp(obj); + if !ms.is_finite() { + return NativeResult::Ok(JsValue::float($df)); + } + match dt_from_ms_local(ms) { + Some(dt) => NativeResult::Ok(JsValue::float(($f)(dt))), + None => NativeResult::Ok(JsValue::float($df)), + } + } + }; +} + make_getter!(date_get_time, |dt: DateTime| dt.timestamp_millis() as f64, f64::NAN); -make_getter!(date_get_full_year, |dt: DateTime| dt.year() as f64, f64::NAN); -make_getter!(date_get_month, |dt: DateTime| dt.month0() as f64, f64::NAN); -make_getter!(date_get_date, |dt: DateTime| dt.day() as f64, f64::NAN); -make_getter!(date_get_day, |dt: DateTime| dt.weekday().num_days_from_sunday() as f64, f64::NAN); -make_getter!(date_get_hours, |dt: DateTime| dt.hour() as f64, f64::NAN); -make_getter!(date_get_minutes, |dt: DateTime| dt.minute() as f64, f64::NAN); -make_getter!(date_get_seconds, |dt: DateTime| dt.second() as f64, f64::NAN); -make_getter!(date_get_milliseconds, |dt: DateTime| dt.timestamp_subsec_millis() as f64, f64::NAN); +make_local_getter!(date_get_full_year, |dt: DateTime| dt.year() as f64, f64::NAN); +make_local_getter!(date_get_month, |dt: DateTime| dt.month0() as f64, f64::NAN); +make_local_getter!(date_get_date, |dt: DateTime| dt.day() as f64, f64::NAN); +make_local_getter!(date_get_day, |dt: DateTime| dt.weekday().num_days_from_sunday() as f64, f64::NAN); +make_local_getter!(date_get_hours, |dt: DateTime| dt.hour() as f64, f64::NAN); +make_local_getter!(date_get_minutes, |dt: DateTime| dt.minute() as f64, f64::NAN); +make_local_getter!(date_get_seconds, |dt: DateTime| dt.second() as f64, f64::NAN); +make_local_getter!(date_get_milliseconds, |dt: DateTime| dt.timestamp_subsec_millis() as f64, f64::NAN); make_utc_getter!(date_get_utc_full_year, |ndt: NaiveDateTime| ndt.date().year() as f64, f64::NAN); make_utc_getter!(date_get_utc_month, |ndt: NaiveDateTime| ndt.date().month0() as f64, f64::NAN); @@ -296,13 +363,21 @@ make_utc_getter!( ); pub fn date_get_timezone_offset(vm: &mut H, args: &[u8]) -> NativeResult { - let _obj = unsafe { &*native_try!(date_this(vm, args)) }; - let offset_min = local_offset_minutes(); + let obj = unsafe { &*native_try!(date_this(vm, args)) }; + let ms = get_timestamp(obj); + let offset_min = local_offset_minutes(ms); NativeResult::Ok(JsValue::float(offset_min as f64)) } -fn local_offset_minutes() -> i32 { - chrono::Local::now().offset().local_minus_utc() / 60 +fn local_offset_minutes(ms: f64) -> i32 { + if !ms.is_finite() { + return 0; + } + let offset = chrono::DateTime::from_timestamp_millis(ms as i64) + .map(|dt| dt.with_timezone(&chrono::Local)) + .map(|dt| dt.offset().local_minus_utc()) + .unwrap_or(0); + -offset / 60 } fn get_opt_arg(vm: &H, args: &[u8], idx: usize, default: u32) -> u32 { @@ -332,7 +407,7 @@ pub fn date_set_full_year(vm: &mut H, args: &[u8]) -> NativeResult { if !ms.is_finite() { return NativeResult::Ok(JsValue::float(f64::NAN)); } - let dt = match dt_from_ms(ms) { + let dt = match dt_from_ms_local(ms) { Some(d) => d, None => return NativeResult::Ok(JsValue::float(f64::NAN)), }; @@ -341,7 +416,7 @@ pub fn date_set_full_year(vm: &mut H, args: &[u8]) -> NativeResult { let nd = dt .with_year(v as i32) .and_then(|x| x.with_month0(m)) - .and_then(|x| x.with_day0(d)) + .and_then(|x| x.with_day0(if args.len() > 3 { d - 1 } else { d })) .unwrap_or(dt); let ts = nd.timestamp_millis() as f64; set_timestamp(obj, ts); @@ -355,12 +430,12 @@ pub fn date_set_month(vm: &mut H, args: &[u8]) -> NativeResult { if !ms.is_finite() { return NativeResult::Ok(JsValue::float(f64::NAN)); } - let dt = match dt_from_ms(ms) { + let dt = match dt_from_ms_local(ms) { Some(d) => d, None => return NativeResult::Ok(JsValue::float(f64::NAN)), }; let d = get_opt_arg(vm, args, 2, dt.day0()); - let nd = dt.with_month0(v as u32).and_then(|x| x.with_day0(d)).unwrap_or(dt); + let nd = dt.with_month0(v as u32).and_then(|x| x.with_day0(if args.len() > 2 { d - 1 } else { d })).unwrap_or(dt); let ts = nd.timestamp_millis() as f64; set_timestamp(obj, ts); NativeResult::Ok(JsValue::float(ts)) @@ -373,7 +448,7 @@ pub fn date_set_date(vm: &mut H, args: &[u8]) -> NativeResult { if !ms.is_finite() { return NativeResult::Ok(JsValue::float(f64::NAN)); } - let dt = match dt_from_ms(ms) { + let dt = match dt_from_ms_local(ms) { Some(d) => d, None => return NativeResult::Ok(JsValue::float(f64::NAN)), }; @@ -390,7 +465,7 @@ pub fn date_set_hours(vm: &mut H, args: &[u8]) -> NativeResult { if !ms.is_finite() { return NativeResult::Ok(JsValue::float(f64::NAN)); } - let dt = match dt_from_ms(ms) { + let dt = match dt_from_ms_local(ms) { Some(d) => d, None => return NativeResult::Ok(JsValue::float(f64::NAN)), }; @@ -415,7 +490,7 @@ pub fn date_set_minutes(vm: &mut H, args: &[u8]) -> NativeResult { if !ms.is_finite() { return NativeResult::Ok(JsValue::float(f64::NAN)); } - let dt = match dt_from_ms(ms) { + let dt = match dt_from_ms_local(ms) { Some(d) => d, None => return NativeResult::Ok(JsValue::float(f64::NAN)), }; @@ -438,7 +513,7 @@ pub fn date_set_seconds(vm: &mut H, args: &[u8]) -> NativeResult { if !ms.is_finite() { return NativeResult::Ok(JsValue::float(f64::NAN)); } - let dt = match dt_from_ms(ms) { + let dt = match dt_from_ms_local(ms) { Some(d) => d, None => return NativeResult::Ok(JsValue::float(f64::NAN)), }; @@ -459,7 +534,7 @@ pub fn date_set_milliseconds(vm: &mut H, args: &[u8]) -> NativeResult if !ms.is_finite() { return NativeResult::Ok(JsValue::float(f64::NAN)); } - let dt = match dt_from_ms(ms) { + let dt = match dt_from_ms_local(ms) { Some(d) => d, None => return NativeResult::Ok(JsValue::float(f64::NAN)), }; @@ -469,6 +544,195 @@ pub fn date_set_milliseconds(vm: &mut H, args: &[u8]) -> NativeResult NativeResult::Ok(JsValue::float(ts)) } +pub fn date_set_utc_full_year(vm: &mut H, args: &[u8]) -> NativeResult { + let obj = unsafe { &mut *native_try!(date_this_mut(vm, args)) }; + let ms = get_timestamp(obj); + if !ms.is_finite() { + return NativeResult::Ok(JsValue::float(f64::NAN)); + } + let ndt = match naive_from_ms(ms) { + Some(n) => n, + None => return NativeResult::Ok(JsValue::float(f64::NAN)), + }; + let y = oxide_runtime_api::to_number(vm.reg(args[1])).trunc() as i32; + let m = get_opt_arg(vm, args, 2, ndt.date().month0()); + let d = get_opt_arg(vm, args, 3, ndt.date().day0()); + let nd = NaiveDate::from_ymd_opt(y, m + 1, if args.len() > 3 { d } else { d + 1 }) + .and_then(|date| date.and_hms_nano_opt(ndt.time().hour(), ndt.time().minute(), ndt.time().second(), ndt.time().nanosecond())) + .unwrap_or(ndt); + let ts = nd.and_utc().timestamp_millis() as f64; + set_timestamp(obj, ts); + NativeResult::Ok(JsValue::float(ts)) +} + +pub fn date_set_utc_month(vm: &mut H, args: &[u8]) -> NativeResult { + let obj = unsafe { &mut *native_try!(date_this_mut(vm, args)) }; + let ms = get_timestamp(obj); + if !ms.is_finite() { + return NativeResult::Ok(JsValue::float(f64::NAN)); + } + let ndt = match naive_from_ms(ms) { + Some(n) => n, + None => return NativeResult::Ok(JsValue::float(f64::NAN)), + }; + let m = oxide_runtime_api::to_number(vm.reg(args[1])).trunc() as u32; + let d = get_opt_arg(vm, args, 2, ndt.date().day0()); + let nd = NaiveDate::from_ymd_opt(ndt.date().year(), m + 1, if args.len() > 2 { d } else { d + 1 }) + .and_then(|date| date.and_hms_nano_opt(ndt.time().hour(), ndt.time().minute(), ndt.time().second(), ndt.time().nanosecond())) + .unwrap_or(ndt); + let ts = nd.and_utc().timestamp_millis() as f64; + set_timestamp(obj, ts); + NativeResult::Ok(JsValue::float(ts)) +} + +pub fn date_set_utc_date(vm: &mut H, args: &[u8]) -> NativeResult { + let obj = unsafe { &mut *native_try!(date_this_mut(vm, args)) }; + let ms = get_timestamp(obj); + if !ms.is_finite() { + return NativeResult::Ok(JsValue::float(f64::NAN)); + } + let ndt = match naive_from_ms(ms) { + Some(n) => n, + None => return NativeResult::Ok(JsValue::float(f64::NAN)), + }; + let d = oxide_runtime_api::to_number(vm.reg(args[1])).trunc() as u32; + let nd = NaiveDate::from_ymd_opt(ndt.date().year(), ndt.date().month(), d) + .and_then(|date| date.and_hms_nano_opt(ndt.time().hour(), ndt.time().minute(), ndt.time().second(), ndt.time().nanosecond())) + .unwrap_or(ndt); + let ts = nd.and_utc().timestamp_millis() as f64; + set_timestamp(obj, ts); + NativeResult::Ok(JsValue::float(ts)) +} + +pub fn date_set_utc_hours(vm: &mut H, args: &[u8]) -> NativeResult { + let obj = unsafe { &mut *native_try!(date_this_mut(vm, args)) }; + let ms = get_timestamp(obj); + if !ms.is_finite() { + return NativeResult::Ok(JsValue::float(f64::NAN)); + } + let ndt = match naive_from_ms(ms) { + Some(n) => n, + None => return NativeResult::Ok(JsValue::float(f64::NAN)), + }; + let h = oxide_runtime_api::to_number(vm.reg(args[1])).trunc() as u32; + let min = get_opt_arg(vm, args, 2, ndt.time().minute()); + let sec = get_opt_arg(vm, args, 3, ndt.time().second()); + let ms_arg = get_opt_arg(vm, args, 4, ndt.time().nanosecond() as u32 / 1_000_000); + let nd = ndt + .with_hour(h) + .and_then(|x| x.with_minute(min)) + .and_then(|x| x.with_second(sec)) + .and_then(|x| x.with_nanosecond(ms_arg * 1_000_000)) + .unwrap_or(ndt); + let ts = nd.and_utc().timestamp_millis() as f64; + set_timestamp(obj, ts); + NativeResult::Ok(JsValue::float(ts)) +} + +pub fn date_set_utc_minutes(vm: &mut H, args: &[u8]) -> NativeResult { + let obj = unsafe { &mut *native_try!(date_this_mut(vm, args)) }; + let ms = get_timestamp(obj); + if !ms.is_finite() { + return NativeResult::Ok(JsValue::float(f64::NAN)); + } + let ndt = match naive_from_ms(ms) { + Some(n) => n, + None => return NativeResult::Ok(JsValue::float(f64::NAN)), + }; + let min = oxide_runtime_api::to_number(vm.reg(args[1])).trunc() as u32; + let sec = get_opt_arg(vm, args, 2, ndt.time().second()); + let ms_arg = get_opt_arg(vm, args, 3, ndt.time().nanosecond() as u32 / 1_000_000); + let nd = ndt + .with_minute(min) + .and_then(|x| x.with_second(sec)) + .and_then(|x| x.with_nanosecond(ms_arg * 1_000_000)) + .unwrap_or(ndt); + let ts = nd.and_utc().timestamp_millis() as f64; + set_timestamp(obj, ts); + NativeResult::Ok(JsValue::float(ts)) +} + +pub fn date_set_utc_seconds(vm: &mut H, args: &[u8]) -> NativeResult { + let obj = unsafe { &mut *native_try!(date_this_mut(vm, args)) }; + let ms = get_timestamp(obj); + if !ms.is_finite() { + return NativeResult::Ok(JsValue::float(f64::NAN)); + } + let ndt = match naive_from_ms(ms) { + Some(n) => n, + None => return NativeResult::Ok(JsValue::float(f64::NAN)), + }; + let sec = oxide_runtime_api::to_number(vm.reg(args[1])).trunc() as u32; + let ms_arg = get_opt_arg(vm, args, 2, ndt.time().nanosecond() as u32 / 1_000_000); + let nd = ndt.with_second(sec).and_then(|x| x.with_nanosecond(ms_arg * 1_000_000)).unwrap_or(ndt); + let ts = nd.and_utc().timestamp_millis() as f64; + set_timestamp(obj, ts); + NativeResult::Ok(JsValue::float(ts)) +} + +pub fn date_set_utc_milliseconds(vm: &mut H, args: &[u8]) -> NativeResult { + let obj = unsafe { &mut *native_try!(date_this_mut(vm, args)) }; + let ms = get_timestamp(obj); + if !ms.is_finite() { + return NativeResult::Ok(JsValue::float(f64::NAN)); + } + let ndt = match naive_from_ms(ms) { + Some(n) => n, + None => return NativeResult::Ok(JsValue::float(f64::NAN)), + }; + let ms_arg = oxide_runtime_api::to_number(vm.reg(args[1])).trunc() as u32; + let nd = ndt.with_nanosecond(ms_arg * 1_000_000).unwrap_or(ndt); + let ts = nd.and_utc().timestamp_millis() as f64; + set_timestamp(obj, ts); + NativeResult::Ok(JsValue::float(ts)) +} + +pub fn date_get_year(vm: &mut H, args: &[u8]) -> NativeResult { + let obj = unsafe { &*native_try!(date_this(vm, args)) }; + let ms = get_timestamp(obj); + if !ms.is_finite() { + return NativeResult::Ok(JsValue::float(f64::NAN)); + } + match dt_from_ms_local(ms) { + Some(dt) => NativeResult::Ok(JsValue::float((dt.year() - 1900) as f64)), + None => NativeResult::Ok(JsValue::float(f64::NAN)), + } +} + +pub fn date_set_year(vm: &mut H, args: &[u8]) -> NativeResult { + let obj = unsafe { &mut *native_try!(date_this_mut(vm, args)) }; + let ms = get_timestamp(obj); + if !ms.is_finite() { + return NativeResult::Ok(JsValue::float(f64::NAN)); + } + let dt = match dt_from_ms_local(ms) { + Some(d) => d, + None => return NativeResult::Ok(JsValue::float(f64::NAN)), + }; + let y = oxide_runtime_api::to_number(vm.reg(args[1])).trunc() as i32; + let full_year = if (0..=99).contains(&y) { y + 1900 } else { y }; + let nd = dt.with_year(full_year).unwrap_or(dt); + let ts = nd.timestamp_millis() as f64; + set_timestamp(obj, ts); + NativeResult::Ok(JsValue::float(ts)) +} + +pub fn date_to_gmt_string(vm: &mut H, args: &[u8]) -> NativeResult { + date_to_utc_string(vm, args) +} + +pub fn date_to_locale_date_string(vm: &mut H, args: &[u8]) -> NativeResult { + date_to_date_string(vm, args) +} + +pub fn date_to_locale_string(vm: &mut H, args: &[u8]) -> NativeResult { + date_to_string(vm, args) +} + +pub fn date_to_locale_time_string(vm: &mut H, args: &[u8]) -> NativeResult { + date_to_time_string(vm, args) +} + fn date_to_string_inner(vm: &mut H, args: &[u8], format_str: &str, invalid: &str) -> NativeResult { let obj = unsafe { &*native_try!(date_this(vm, args)) }; let ms = get_timestamp(obj); diff --git a/crates/oxide_vm/src/bindings/bind_date.rs b/crates/oxide_vm/src/bindings/bind_date.rs index 5b1d7324..2727eb6c 100644 --- a/crates/oxide_vm/src/bindings/bind_date.rs +++ b/crates/oxide_vm/src/bindings/bind_date.rs @@ -83,12 +83,69 @@ pub fn bind_date(core: &Arc, session: &KernelSession, global: &mut J oxide_builtins::date::date_set_milliseconds:: as *const (), 1, ), + ( + "setUTCFullYear", + oxide_builtins::date::date_set_utc_full_year:: as *const (), + 3, + ), + ( + "setUTCMonth", + oxide_builtins::date::date_set_utc_month:: as *const (), + 2, + ), + ( + "setUTCDate", + oxide_builtins::date::date_set_utc_date:: as *const (), + 1, + ), + ( + "setUTCHours", + oxide_builtins::date::date_set_utc_hours:: as *const (), + 4, + ), + ( + "setUTCMinutes", + oxide_builtins::date::date_set_utc_minutes:: as *const (), + 3, + ), + ( + "setUTCSeconds", + oxide_builtins::date::date_set_utc_seconds:: as *const (), + 2, + ), + ( + "setUTCMilliseconds", + oxide_builtins::date::date_set_utc_milliseconds:: as *const (), + 1, + ), + ("getYear", oxide_builtins::date::date_get_year:: as *const (), 0), + ("setYear", oxide_builtins::date::date_set_year:: as *const (), 1), ("toISOString", oxide_builtins::date::date_to_iso_string:: as *const (), 0), ("toJSON", oxide_builtins::date::date_to_json:: as *const (), 1), ("toString", oxide_builtins::date::date_to_string:: as *const (), 0), ("toDateString", oxide_builtins::date::date_to_date_string:: as *const (), 0), ("toTimeString", oxide_builtins::date::date_to_time_string:: as *const (), 0), ("toUTCString", oxide_builtins::date::date_to_utc_string:: as *const (), 0), + ( + "toGMTString", + oxide_builtins::date::date_to_gmt_string:: as *const (), + 0, + ), + ( + "toLocaleDateString", + oxide_builtins::date::date_to_locale_date_string:: as *const (), + 0, + ), + ( + "toLocaleString", + oxide_builtins::date::date_to_locale_string:: as *const (), + 0, + ), + ( + "toLocaleTimeString", + oxide_builtins::date::date_to_locale_time_string:: as *const (), + 0, + ), ("valueOf", oxide_builtins::date::date_value_of:: as *const (), 0), ], ); diff --git a/crates/oxide_vm/tests/builtins_date_tests.rs b/crates/oxide_vm/tests/builtins_date_tests.rs index 6be7816b..87b4519d 100644 --- a/crates/oxide_vm/tests/builtins_date_tests.rs +++ b/crates/oxide_vm/tests/builtins_date_tests.rs @@ -100,7 +100,8 @@ fn date_value_of() { #[test] fn date_to_iso_string() { let mut vm = Vm::new(); - let r = eval(&mut vm, "new Date(2020, 0, 1, 0, 0, 0).toISOString()").unwrap(); + // Parse an explicit ISO UTC string to avoid timezone dependency + let r = eval(&mut vm, "new Date('2020-01-01T00:00:00Z').toISOString()").unwrap(); let s = str_val(&vm, r); assert!(s.starts_with("2020-01-01"), "got: {s}"); } @@ -133,3 +134,194 @@ fn date_objects_use_bounded_numeric_coercion() { let r = eval(&mut vm, "+new Date(0)").unwrap(); assert_eq!(r.as_double(), 0.0); } + +// -- Plan 01 timezone-correct tests -- + +#[test] +fn date_local_getters_differ_from_utc() { + let mut vm = Vm::new(); + let r = eval(&mut vm, "var d = new Date(2020, 6, 15, 12, 0, 0); d.getHours()").unwrap(); + let local_hour = r.as_double(); + let r = eval(&mut vm, "var d = new Date(2020, 6, 15, 12, 0, 0); d.getUTCHours()").unwrap(); + let utc_hour = r.as_double(); + // In UTC+0 they are equal (correct), otherwise they differ + if utc_hour != local_hour { + assert_ne!(local_hour, utc_hour, "in non-UTC+0, local vs UTC hours should differ"); + } + assert!(local_hour >= 0.0 && local_hour < 24.0); +} + +#[test] +fn date_constructor_uses_local_timezone() { + let mut vm = Vm::new(); + // getTimezoneOffset = UTC - local; UTC hour = local + offset/60 + let r = eval(&mut vm, "var d = new Date(2020, 0, 1, 12, 0, 0); d.getUTCHours()").unwrap(); + let utc_hour = r.as_double(); + let r = eval(&mut vm, "var d = new Date(2020, 0, 1, 12, 0, 0); d.getTimezoneOffset()").unwrap(); + let offset = r.as_double(); + let expected_utc = (12.0 + offset / 60.0).rem_euclid(24.0); + assert_eq!(utc_hour, expected_utc, "getUTCHours = local + TZ_offset/60"); +} + +#[test] +fn date_constructor_defaults_from_current_time() { + let mut vm = Vm::new(); + // D-02: missing args default to current time components + let r = eval(&mut vm, "var d = new Date(2020, 5); d.getMonth()").unwrap(); + assert_eq!(r.as_double(), 5.0); + let r = eval(&mut vm, "new Date(2020, 5).getDate()").unwrap(); + assert!(r.as_double() >= 1.0 && r.as_double() <= 31.0); +} + +#[test] +fn date_constructor_truncation() { + let mut vm = Vm::new(); + // D-03: ToInteger truncation + let r = eval(&mut vm, "new Date(2024.7, 5.9).getFullYear()").unwrap(); + assert_eq!(r.as_double(), 2024.0); + let r = eval(&mut vm, "new Date(2024.7, 5.9).getMonth()").unwrap(); + assert_eq!(r.as_double(), 5.0); +} + +#[test] +fn date_setters_return_timestamp() { + let mut vm = Vm::new(); + // D-05: setters return modified timestamp + let r = eval(&mut vm, "var d = new Date(0); var ts = d.setHours(12); ts == d.getTime() ? 1 : 0").unwrap(); + assert_eq!(r.as_int(), 1); +} + +#[test] +fn date_invalid_returns_nan() { + let mut vm = Vm::new(); + // D-06: Invalid Date getters/setters return NaN + let r = eval(&mut vm, "new Date(NaN).getFullYear()").unwrap(); + assert!(r.as_double().is_nan()); + let r = eval(&mut vm, "new Date(NaN).setHours(0)").unwrap(); + assert!(r.as_double().is_nan()); + // D-04: Invalid Date constructor + let r = eval(&mut vm, "new Date(NaN, 0).getTime()").unwrap(); + assert!(r.as_double().is_nan()); +} + +#[test] +fn date_get_timezone_offset_uses_date_timestamp() { + let mut vm = Vm::new(); + // D-09/D-10: offset uses date's timestamp, not now() + let r = eval(&mut vm, "new Date(0).getTimezoneOffset()").unwrap(); + assert!(r.as_double().is_finite()); +} + +#[test] +fn date_setters_optional_chain() { + let mut vm = Vm::new(); + // D-08: setFullYear supports optional month/day params + let r = eval(&mut vm, "var d = new Date(2020, 0, 1); d.setFullYear(2025, 11, 25); d.getFullYear()").unwrap(); + assert_eq!(r.as_double(), 2025.0); + let r = eval(&mut vm, "var d = new Date(2020, 0, 1); d.setFullYear(2025, 11, 25); d.getMonth()").unwrap(); + assert_eq!(r.as_double(), 11.0); + let r = eval(&mut vm, "var d = new Date(2020, 0, 1); d.setFullYear(2025, 11, 25); d.getDate()").unwrap(); + assert_eq!(r.as_double(), 25.0); +} + +#[test] +fn date_local_setters_preserve_utc_offset() { + let mut vm = Vm::new(); + // setHours changes local hour; verify local hour value + let r = eval(&mut vm, "var d = new Date(2020, 0, 1, 0, 0, 0); d.setHours(12); d.getHours()").unwrap(); + assert_eq!(r.as_double(), 12.0, "setHours(12) should make getHours() return 12"); +} + +// -- Plan 02 new method tests -- + +#[test] +fn date_set_utc_full_year_works() { + let mut vm = Vm::new(); + let r = eval(&mut vm, "var d = new Date(2020, 0, 1, 0, 0, 0); d.setUTCFullYear(2025); d.getUTCFullYear()").unwrap(); + assert_eq!(r.as_double(), 2025.0); +} + +#[test] +fn date_set_utc_hours_optional_chain() { + let mut vm = Vm::new(); + let r = eval(&mut vm, "var d = new Date(2020, 0, 1, 0, 0, 0); d.setUTCHours(23, 59, 59, 999); d.getUTCHours()").unwrap(); + assert_eq!(r.as_double(), 23.0); + let r = eval(&mut vm, "var d = new Date(2020, 0, 1, 0, 0, 0); d.setUTCHours(23, 59, 59, 999); d.getUTCMinutes()").unwrap(); + assert_eq!(r.as_double(), 59.0); + let r = eval(&mut vm, "var d = new Date(2020, 0, 1, 0, 0, 0); d.setUTCHours(23, 59, 59, 999); d.getUTCSeconds()").unwrap(); + assert_eq!(r.as_double(), 59.0); + let r = eval(&mut vm, "var d = new Date(2020, 0, 1, 0, 0, 0); d.setUTCHours(23, 59, 59, 999); d.getUTCMilliseconds()").unwrap(); + assert_eq!(r.as_double(), 999.0); +} + +#[test] +fn date_utc_returns_correct_timestamp() { + let mut vm = Vm::new(); + let r = eval(&mut vm, "Date.UTC(2020, 0, 1, 12, 0, 0)").unwrap(); + assert_eq!(r.as_double(), 1577880000000.0); +} + +#[test] +fn date_utc_nan_returns_nan() { + let mut vm = Vm::new(); + let r = eval(&mut vm, "Date.UTC(NaN, 0)").unwrap(); + assert!(r.as_double().is_nan()); +} + +#[test] +fn date_parse_rfc2822() { + let mut vm = Vm::new(); + let r = eval(&mut vm, "Date.parse('15 Jan 2020 12:00:00 GMT')").unwrap(); + assert!(!r.as_double().is_nan()); +} + +#[test] +fn date_parse_slash_format() { + let mut vm = Vm::new(); + let r = eval(&mut vm, "Date.parse('2020/01/15')").unwrap(); + assert!(!r.as_double().is_nan()); +} + +#[test] +fn date_get_year_deprecated() { + let mut vm = Vm::new(); + let r = eval(&mut vm, "new Date(2020, 0, 1).getYear()").unwrap(); + assert_eq!(r.as_double(), 120.0); +} + +#[test] +fn date_set_year_deprecated() { + let mut vm = Vm::new(); + // setYear(0-99) adds 1900; setYear(20) → fullYear 1920 + let r = eval(&mut vm, "var d = new Date(2020, 0, 1); d.setYear(20); d.getFullYear()").unwrap(); + assert_eq!(r.as_double(), 1920.0); +} + +#[test] +fn date_to_gmt_string_matches_utc() { + let mut vm = Vm::new(); + let r1 = eval(&mut vm, "new Date(0).toGMTString()").unwrap(); + let r2 = eval(&mut vm, "new Date(0).toUTCString()").unwrap(); + assert_eq!(str_val(&vm, r1), str_val(&vm, r2)); +} + +#[test] +fn date_locale_strings_not_empty() { + let mut vm = Vm::new(); + let r = eval(&mut vm, "new Date(0).toLocaleString()").unwrap(); + assert!(r.is_string()); +} + +#[test] +fn date_set_utc_full_year_returns_timestamp() { + let mut vm = Vm::new(); + let r = eval(&mut vm, "var d = new Date(0); var ts = d.setUTCFullYear(2025); ts == d.getTime() ? 1 : 0").unwrap(); + assert_eq!(r.as_int(), 1); +} + +#[test] +fn date_set_utc_invalid_returns_nan() { + let mut vm = Vm::new(); + let r = eval(&mut vm, "new Date(NaN).setUTCFullYear(2025)").unwrap(); + assert!(r.as_double().is_nan()); +}