Files
faunosteo/crates/core/src/json.rs
T
bchanot 343d6f4c1f feat(workspace): R2.4 core runtime — lazy load, poison on trap, offline re-instantiation, per-generation sheet handles
packages/core-wasm: browser-safe CoreRuntime (synchronous calls once ready;
a WebAssembly.RuntimeError poisons the instance, the call answers internal,
a fresh instance comes from the kept compiled module and a glue record
imported in advance; at most 3 recoveries per page; retry after a load
failure), SheetSession (handle rebuilt per instance generation, never
called on a dropped one; invalid_sheet without poisoning), Node source.
crates/wasm: SheetHandle (sheet held in the module memory). Two builds:
pkg/ shipped without trap exports (checked), pkg-proofs/ for the trap
tests; BUILD_STAMP (hash of the Rust sources) refused when missing or
stale by the vitest global setup instead of skipping. Failure envelope
carries a numeric found version; compact JS-number output.
2026-10-14 00:12:04 +02:00

265 lines
8.5 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! JSON output with JavaScript number semantics.
//!
//! `JSON.stringify(value, null, 2)` and `serde_json`'s pretty printer agree on everything
//! (two-space indent, `": "`, `[]` and `{}` for empty containers, raw non-ASCII, `\u00XX`
//! control escapes) except finite floats: JavaScript prints `1523` for `1523.0` and `1e+21`
//! for `1e21`, `serde_json` prints `1523.0` and `1e21`. The documents of the repository carry
//! integer-valued coordinates as floats, so the archive attachment and the generated seed
//! files need the JavaScript form (review I.2, D-R11).
use std::io;
use serde::Serialize;
use serde_json::ser::{Formatter, PrettyFormatter};
/// Formats a finite `f64` exactly as ECMAScript `Number::toString(10)` does.
///
/// Non-finite values have no JSON form (`JSON.stringify` writes `null`): same here.
pub fn js_number(value: f64) -> String {
if !value.is_finite() {
return "null".to_owned();
}
if value == 0.0 {
return "0".to_owned();
}
let (digits, point) = shortest_digits(value.abs());
let mut out = String::with_capacity(digits.len() + 8);
if value.is_sign_negative() {
out.push('-');
}
write_decimal(&mut out, &digits, point);
out
}
/// Shortest round-trip digits of a positive finite value and the position `n` of the
/// decimal point relative to the first digit (ECMAScript's `n`): value = 0.d₁d₂… × 10ⁿ.
///
/// Rust's `LowerExp` prints the shortest round-trip mantissa (`1.7154285714285713e3`),
/// chosen by the same rule as ECMAScript (shortest, then closest to the value).
fn shortest_digits(value: f64) -> (String, i32) {
let scientific = format!("{value:e}");
let (mantissa, exponent) = scientific
.split_once('e')
.unwrap_or((scientific.as_str(), "0"));
let exponent: i32 = exponent.parse().unwrap_or(0);
let digits: String = mantissa.chars().filter(char::is_ascii_digit).collect();
(digits, exponent + 1)
}
/// ECMAScript Number::toString steps 6 to 10 for `k` digits and point position `n`.
fn write_decimal(out: &mut String, digits: &str, n: i32) {
let k = i32::try_from(digits.len()).unwrap_or(i32::MAX);
if k <= n && n <= 21 {
out.push_str(digits);
out.extend(std::iter::repeat_n('0', (n - k).unsigned_abs() as usize));
} else if 0 < n && n <= 21 {
let (integer, fraction) = digits.split_at(n.unsigned_abs() as usize);
out.push_str(integer);
out.push('.');
out.push_str(fraction);
} else if -6 < n && n <= 0 {
out.push_str("0.");
out.extend(std::iter::repeat_n('0', n.unsigned_abs() as usize));
out.push_str(digits);
} else {
let (first, rest) = digits.split_at(1);
out.push_str(first);
if !rest.is_empty() {
out.push('.');
out.push_str(rest);
}
let exponent = n - 1;
out.push('e');
out.push(if exponent < 0 { '-' } else { '+' });
out.push_str(&exponent.unsigned_abs().to_string());
}
}
/// `serde_json`'s pretty formatter with JavaScript float printing.
pub struct JsPrettyFormatter<'a> {
inner: PrettyFormatter<'a>,
}
impl Default for JsPrettyFormatter<'_> {
fn default() -> Self {
Self {
inner: PrettyFormatter::new(),
}
}
}
impl Formatter for JsPrettyFormatter<'_> {
fn write_f32<W>(&mut self, writer: &mut W, value: f32) -> io::Result<()>
where
W: ?Sized + io::Write,
{
writer.write_all(js_number(f64::from(value)).as_bytes())
}
fn write_f64<W>(&mut self, writer: &mut W, value: f64) -> io::Result<()>
where
W: ?Sized + io::Write,
{
writer.write_all(js_number(value).as_bytes())
}
fn begin_array<W>(&mut self, writer: &mut W) -> io::Result<()>
where
W: ?Sized + io::Write,
{
self.inner.begin_array(writer)
}
fn end_array<W>(&mut self, writer: &mut W) -> io::Result<()>
where
W: ?Sized + io::Write,
{
self.inner.end_array(writer)
}
fn begin_array_value<W>(&mut self, writer: &mut W, first: bool) -> io::Result<()>
where
W: ?Sized + io::Write,
{
self.inner.begin_array_value(writer, first)
}
fn end_array_value<W>(&mut self, writer: &mut W) -> io::Result<()>
where
W: ?Sized + io::Write,
{
self.inner.end_array_value(writer)
}
fn begin_object<W>(&mut self, writer: &mut W) -> io::Result<()>
where
W: ?Sized + io::Write,
{
self.inner.begin_object(writer)
}
fn end_object<W>(&mut self, writer: &mut W) -> io::Result<()>
where
W: ?Sized + io::Write,
{
self.inner.end_object(writer)
}
fn begin_object_key<W>(&mut self, writer: &mut W, first: bool) -> io::Result<()>
where
W: ?Sized + io::Write,
{
self.inner.begin_object_key(writer, first)
}
fn begin_object_value<W>(&mut self, writer: &mut W) -> io::Result<()>
where
W: ?Sized + io::Write,
{
self.inner.begin_object_value(writer)
}
fn end_object_value<W>(&mut self, writer: &mut W) -> io::Result<()>
where
W: ?Sized + io::Write,
{
self.inner.end_object_value(writer)
}
}
/// Serialises `value` as `JSON.stringify(value, null, 2)` would (no trailing newline).
pub fn to_js_pretty<T: Serialize + ?Sized>(value: &T) -> Result<String, serde_json::Error> {
let mut buffer = Vec::new();
let mut serializer =
serde_json::Serializer::with_formatter(&mut buffer, JsPrettyFormatter::default());
value.serialize(&mut serializer)?;
String::from_utf8(buffer).map_err(<serde_json::Error as serde::ser::Error>::custom)
}
/// `serde_json`'s compact formatter with JavaScript float printing (`JSON.stringify(value)`).
#[derive(Default)]
pub struct JsCompactFormatter;
impl Formatter for JsCompactFormatter {
fn write_f32<W>(&mut self, writer: &mut W, value: f32) -> io::Result<()>
where
W: ?Sized + io::Write,
{
writer.write_all(js_number(f64::from(value)).as_bytes())
}
fn write_f64<W>(&mut self, writer: &mut W, value: f64) -> io::Result<()>
where
W: ?Sized + io::Write,
{
writer.write_all(js_number(value).as_bytes())
}
}
/// Serialises `value` as `JSON.stringify(value)` would.
pub fn to_js_compact<T: Serialize + ?Sized>(value: &T) -> Result<String, serde_json::Error> {
let mut buffer = Vec::new();
let mut serializer = serde_json::Serializer::with_formatter(&mut buffer, JsCompactFormatter);
value.serialize(&mut serializer)?;
String::from_utf8(buffer).map_err(<serde_json::Error as serde::ser::Error>::custom)
}
/// Parses JSON text and re-emits it in the JavaScript pretty form, keeping the key order.
pub fn pretty_js_round_trip(text: &str) -> Result<String, serde_json::Error> {
let value: serde_json::Value = serde_json::from_str(text)?;
to_js_pretty(&value)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn integer_valued_floats_print_without_a_fraction() {
assert_eq!(js_number(1523.0), "1523");
assert_eq!(js_number(-7.0), "-7");
assert_eq!(
js_number(123_456_789_012_345_680_000.0),
"123456789012345680000"
);
}
#[test]
fn fractions_and_small_values_follow_the_javascript_thresholds() {
assert_eq!(js_number(0.85), "0.85");
assert_eq!(js_number(1_715.428_571_428_571_3), "1715.4285714285713");
assert_eq!(js_number(0.000_001), "0.000001");
assert_eq!(js_number(0.000_000_1), "1e-7");
assert_eq!(js_number(1e21), "1e+21");
assert_eq!(js_number(1.5e300), "1.5e+300");
assert_eq!(js_number(5e-324), "5e-324");
}
#[test]
fn zero_and_non_finite_values() {
assert_eq!(js_number(0.0), "0");
assert_eq!(js_number(-0.0), "0");
assert_eq!(js_number(f64::NAN), "null");
assert_eq!(js_number(f64::INFINITY), "null");
}
#[test]
fn compact_output_prints_floats_as_javascript() {
let value = serde_json::json!({"a": [1.0, 0.5, 1e21], "b": "\u{1}"});
assert_eq!(
to_js_compact(&value).ok().as_deref(),
Some(r#"{"a":[1,0.5,1e+21],"b":"\u0001"}"#)
);
}
#[test]
fn pretty_output_matches_the_javascript_shape() {
let text = r#"{"b":[1,2.0,{"c":[]}],"a":{},"d":"é\u0001","e":-0.0}"#;
let expected = "{\n \"b\": [\n 1,\n 2,\n {\n \"c\": []\n }\n ],\n \"a\": {},\n \"d\": \"é\\u0001\",\n \"e\": 0\n}";
let Ok(actual) = pretty_js_round_trip(text) else {
panic!("round trip failed");
};
assert_eq!(actual, expected);
}
}