mf2_host_web/

numbers.rs

//! Numbers through the browser (`plans/03-runtime.md` §2.7, "the `intl`
//! option"; §5.3): a [`NumberFormatter`] whose `format` is
//! `Intl.NumberFormat` (`format`, and `formatToParts` for sub-parts) and
//! whose `plural` is `Intl.PluralRules`, given by `Host::numbers` only when
//! the engine has `Intl.NumberFormat` v3, which every MF2 digit option
//! needs (owner decision 4) — detected once and remembered.
//!
//! One inline-JS module caches one `Intl.NumberFormat` and one
//! `Intl.PluralRules` per locale and option set (FIFO, 256: a message whose
//! options come from variables must not keep one object per value alive).
//! The options travel as a JSON object built here into a fixed buffer (no
//! allocation, no `core::fmt`) and are parsed once per cache entry; the
//! value travels as its exact decimal text, which `Intl.NumberFormat` v3
//! formats exactly (`Intl.PluralRules.select` converts it to a JS number).
//!
//! The mapping: MF2's option names and values are ECMA-402's. A neutral
//! request is locale `en` with `numberingSystem: "latn"` and `useGrouping:
//! false`; `currencyDisplay=never` formats with `code` and drops the
//! `currency` part and the spacing next to it; digit options equal to
//! `Intl`'s defaults for the style are left out.

use alloc::string::String;
use core::sync::atomic::{AtomicU8, Ordering};

use mf2_runtime::{
    Category, CurrencyDisplay, DateTimeRequest, DigitOptions, Grouping, Host, NumberFormatter,
    NumberOut, NumberRequest, NumberStyle, RoundingMode, RoundingPriority, SignDisplay, Sink,
    UnitDisplay,
};
use wasm_bindgen::prelude::wasm_bindgen;

use crate::HOST;

/// A host with numbers through `Intl` (feature `intl`): the number methods
/// here, every other method from the host it wraps — [`crate::HOST`], or
/// a date host (`IntlNumbers(&INTL_HOST)` for a corpus with dates under
/// `datetime-intl`). Its own static, like the date hosts, so a client that
/// formats no numbers names a host without this glue (B1′). It forwards
/// each `Host` method; a method added to the trait later must be forwarded
/// here too.
#[derive(Clone, Copy)]
pub struct IntlNumbers(pub &'static dyn Host);

/// [`IntlNumbers`] over [`crate::HOST`], for
/// [`mf2_runtime::FormatContext::new`].
pub static NUMBERS_HOST: IntlNumbers = IntlNumbers(&HOST);

impl Host for IntlNumbers {
    fn nfc<'a>(&self, s: &'a str, buf: &'a mut String) -> &'a str {
        self.0.nfc(s, buf)
    }

    fn f64_to_text<'b>(&self, x: f64, buf: &'b mut [u8; 32]) -> Option<&'b str> {
        self.0.f64_to_text(x, buf)
    }

    fn zone_offset(&self, zone: &str, epoch_ms: i64) -> Option<i32> {
        self.0.zone_offset(zone, epoch_ms)
    }

    fn format_date_time(
        &self,
        locale: &str,
        request: &DateTimeRequest<'_>,
        out: &mut dyn Sink,
    ) -> bool {
        self.0.format_date_time(locale, request, out)
    }

    fn numbers(&self) -> Option<&dyn NumberFormatter> {
        available().then_some(&INTL)
    }
}

/// `Intl.NumberFormat` and `Intl.PluralRules`, for an engine with
/// `Intl.NumberFormat` v3 ([`IntlNumbers`] hands it out only then).
struct Intl;

static INTL: Intl = Intl;

impl NumberFormatter for Intl {
    fn format(&self, locale: &str, request: &NumberRequest<'_>, out: NumberOut<'_>) -> bool {
        format(locale, request, out)
    }

    fn plural(&self, locale: &str, request: &NumberRequest<'_>) -> Option<Category> {
        plural(locale, request)
    }
}

// The JavaScript, minified by hand (it ships as written; A0 measured its
// size, bench/intl-probe). `g(cache, key, plural)`: the cached
// `Intl.PluralRules` or `Intl.NumberFormat` for a key `locale U+0001 JSON
// options` (one string across the boundary, parsed only on a miss; FIFO, 256
// per cache; `null` when the engine rejects the set), with
// `currencyDisplay: "never"` mapped to `code` and `h` set. `mf2_nf`: the text,
// or the parts as `type U+001F value` records separated by U+001E, dropping
// for `h` the currency and a blank literal next to it; `undefined` when
// rejected. `mf2_pr`: the category's code (0 zero … 5 other; 6 rejected).
// `mf2_nf_v3`: `Intl.NumberFormat` v3 by behaviour, not `resolvedOptions()`
// (Chromium 143 resolves `roundingPriority` to "auto" yet honours it) — each
// test fails on an engine that ignores the option.
#[wasm_bindgen(inline_js = r#"
const N=new Map,P=new Map,K={zero:0,one:1,two:2,few:3,many:4,other:5};
function g(c,y,k){let f=c.get(y);if(f===void 0){const i=y.indexOf('\x01'),l=y.slice(0,i),o=JSON.parse(y.slice(i+1)),h=o.currencyDisplay=='never';h&&(o.currencyDisplay='code');try{f={i:k?new Intl.PluralRules(l,o):new Intl.NumberFormat(l,o),h}}catch{f=null}c.size>255&&c.delete(c.keys().next().value);c.set(y,f)}return f}
export function mf2_nf(y,v,p){const f=g(N,y,0);if(f===null)return;if(!p&&!f.h)return f.i.format(v);const q=f.i.formatToParts(v);let r='';for(let i=0;i<q.length;i++){const t=q[i];if(f.h&&(t.type=='currency'||t.type=='literal'&&!t.value.trim()&&(q[i-1]?.type=='currency'||q[i+1]?.type=='currency')))continue;r+=p?(r?'\x1e':'')+t.type+'\x1f'+t.value:t.value}return r}
export function mf2_pr(y,v){const f=g(P,y,1);return f===null?6:K[f.i.select(+v)]}
export function mf2_nf_v3(){try{const f=(o,v)=>new Intl.NumberFormat('en',o).format(v);return f({maximumFractionDigits:1,maximumSignificantDigits:1,roundingPriority:'morePrecision'},1.25)=='1.3'&&f({maximumFractionDigits:0,roundingMode:'halfEven'},2.5)=='2'&&f({minimumFractionDigits:2,maximumFractionDigits:2,roundingIncrement:5},'1.23')=='1.25'&&f({minimumFractionDigits:2,trailingZeroDisplay:'stripIfInteger'},1)=='1'&&f({useGrouping:'min2'},1e3)=='1000'&&f({signDisplay:'negative'},-0)=='0'&&f({useGrouping:!1,maximumFractionDigits:20},'9007199254740993.5')=='9007199254740993.5'&&new Intl.PluralRules('en',{maximumFractionDigits:0,roundingMode:'floor'}).select(1.9)=='one'}catch{return!1}}
"#)]
extern "C" {
    fn mf2_nf(key: &str, value: &str, parts: bool) -> Option<alloc::string::String>;
    fn mf2_pr(key: &str, value: &str) -> u32;
    fn mf2_nf_v3() -> bool;
}

/// 0: not yet detected, 1: `Intl.NumberFormat` v3, 2: not.
static V3: AtomicU8 = AtomicU8::new(0);

/// Whether the engine has `Intl.NumberFormat` v3 (asked once).
fn available() -> bool {
    match V3.load(Ordering::Relaxed) {
        1 => true,
        2 => false,
        _ => {
            let yes = mf2_nf_v3();
            V3.store(if yes { 1 } else { 2 }, Ordering::Relaxed);
            yes
        }
    }
}

/// A formatter's key — the locale, U+0001, and its options as a JSON
/// object — written into a fixed buffer; too long → `None`. The longest
/// option set, a 64-byte unit identifier with every option at its longest
/// value, is 451 bytes; the rest holds the locale tag.
struct Json {
    buf: [u8; 640],
    len: usize,
    ok: bool,
    fields: u8,
}

impl Json {
    fn new(locale: &str) -> Json {
        let mut j = Json {
            buf: [0; 640],
            len: 0,
            ok: true,
            fields: 0,
        };
        j.raw(locale);
        j.raw("\u{1}");
        j
    }

    fn raw(&mut self, s: &str) {
        for &b in s.as_bytes() {
            let Some(slot) = self.buf.get_mut(self.len) else {
                self.ok = false;
                return;
            };
            *slot = b;
            self.len += 1;
        }
    }

    fn key(&mut self, k: &str) {
        self.raw(if self.fields == 0 { "{\"" } else { ",\"" });
        self.fields = self.fields.saturating_add(1);
        self.raw(k);
        self.raw("\":");
    }

    /// `"k":"v"` — `v` needs no escaping: option words, currency codes and
    /// unit identifiers are ASCII letters, digits and `-`.
    fn text(&mut self, k: &str, v: &str) {
        self.key(k);
        self.raw("\"");
        self.raw(v);
        self.raw("\"");
    }

    fn number(&mut self, k: &str, v: u16) {
        self.key(k);
        let mut d = [0u8; 5];
        let mut at = d.len();
        let mut v = v;
        loop {
            at -= 1;
            if let Some(slot) = d.get_mut(at) {
                // `v % 10 < 10`.
                #[allow(clippy::cast_possible_truncation)]
                {
                    *slot = b'0' + (v % 10) as u8;
                }
            }
            v /= 10;
            if v == 0 || at == 0 {
                break;
            }
        }
        self.raw(core::str::from_utf8(d.get(at..).unwrap_or(&[])).unwrap_or("0"));
    }

    fn finish(&mut self) -> Option<&str> {
        self.raw(if self.fields == 0 { "{}" } else { "}" });
        if !self.ok {
            return None;
        }
        core::str::from_utf8(self.buf.get(..self.len)?).ok()
    }
}

fn mode_name(m: RoundingMode) -> &'static str {
    match m {
        RoundingMode::Ceil => "ceil",
        RoundingMode::Floor => "floor",
        RoundingMode::Expand => "expand",
        RoundingMode::Trunc => "trunc",
        RoundingMode::HalfCeil => "halfCeil",
        RoundingMode::HalfFloor => "halfFloor",
        RoundingMode::HalfTrunc => "halfTrunc",
        RoundingMode::HalfEven => "halfEven",
        // `halfExpand`, the default, and (not exhaustive) a mode this
        // version does not know; as below, an unknown value is the default.
        _ => "halfExpand",
    }
}

/// The digit options, those equal to `Intl`'s defaults for a style whose
/// default fraction digits are `defaults` (`None`: a currency's own, so
/// always written) left out.
fn digits(d: &DigitOptions, defaults: Option<(u8, u8)>, j: &mut Json) {
    if d.minimum_integer != 1 {
        j.number("minimumIntegerDigits", d.minimum_integer.into());
    }
    if let Some((mn, mx)) = d.fraction
        && defaults != Some((mn, mx))
    {
        j.number("minimumFractionDigits", mn.into());
        j.number("maximumFractionDigits", mx.into());
    }
    if let Some((mn, mx)) = d.significant {
        j.number("minimumSignificantDigits", mn.into());
        j.number("maximumSignificantDigits", mx.into());
    }
    match d.priority {
        RoundingPriority::MorePrecision => j.text("roundingPriority", "morePrecision"),
        RoundingPriority::LessPrecision => j.text("roundingPriority", "lessPrecision"),
        _ => {}
    }
    if d.increment != 1 {
        j.number("roundingIncrement", d.increment);
    }
    if d.mode != RoundingMode::HalfExpand {
        j.text("roundingMode", mode_name(d.mode));
    }
    if d.strip_if_integer {
        j.text("trailingZeroDisplay", "stripIfInteger");
    }
}

/// The `Intl.NumberFormat` options of `r`.
fn format_options(r: &NumberRequest<'_>, j: &mut Json) {
    let defaults = match r.style {
        NumberStyle::Percent => {
            j.text("style", "percent");
            Some((0, 0))
        }
        NumberStyle::Currency {
            code,
            display,
            accounting,
            ..
        } => {
            j.text("style", "currency");
            j.text("currency", code);
            let d = match display {
                CurrencyDisplay::NarrowSymbol => Some("narrowSymbol"),
                CurrencyDisplay::Name => Some("name"),
                CurrencyDisplay::Code => Some("code"),
                CurrencyDisplay::Never => Some("never"),
                // `symbol`, the default, or a value this version does not know.
                _ => None,
            };
            if let Some(d) = d {
                j.text("currencyDisplay", d);
            }
            if accounting {
                j.text("currencySign", "accounting");
            }
            None
        }
        NumberStyle::Unit { unit, display } => {
            j.text("style", "unit");
            j.text("unit", unit);
            match display {
                UnitDisplay::Narrow => j.text("unitDisplay", "narrow"),
                UnitDisplay::Long => j.text("unitDisplay", "long"),
                _ => {}
            }
            Some((0, 3))
        }
        _ => Some((0, 3)),
    };
    if r.neutral {
        j.text("numberingSystem", "latn");
        j.key("useGrouping");
        j.raw("false");
    } else {
        match r.grouping {
            Grouping::Always => j.text("useGrouping", "always"),
            Grouping::Min2 => j.text("useGrouping", "min2"),
            Grouping::Never => {
                j.key("useGrouping");
                j.raw("false");
            }
            _ => {}
        }
    }
    let sign = match r.sign {
        SignDisplay::Always => Some("always"),
        SignDisplay::ExceptZero => Some("exceptZero"),
        SignDisplay::Negative => Some("negative"),
        SignDisplay::Never => Some("never"),
        // `auto`, the default, or a value this version does not know.
        _ => None,
    };
    if let Some(s) = sign {
        j.text("signDisplay", s);
    }
    digits(&r.digits, defaults, j);
}

/// Formats `r` for `locale` with `Intl.NumberFormat`; `false` when the
/// engine rejects the option set (a unit it does not sanction).
fn format(locale: &str, r: &NumberRequest<'_>, out: NumberOut<'_>) -> bool {
    let mut j = Json::new(if r.neutral { "en" } else { locale });
    format_options(r, &mut j);
    let Some(key) = j.finish() else {
        return false;
    };
    let parts = matches!(out, NumberOut::Parts(_));
    let Some(text) = mf2_nf(key, r.value, parts) else {
        return false;
    };
    match out {
        NumberOut::Text(out) => out.push_str(&text),
        NumberOut::Parts(out) => {
            // Records `type U+001F value`, separated by U+001E: ASCII bytes,
            // so every split point is a char boundary.
            let mut rest = text.as_str();
            while !rest.is_empty() {
                let end = rest.bytes().position(|b| b == 0x1e).unwrap_or(rest.len());
                let record = rest.get(..end).unwrap_or("");
                if let Some(i) = record.bytes().position(|b| b == 0x1f) {
                    out.sub_part(
                        record.get(..i).unwrap_or(""),
                        record.get(i + 1..).unwrap_or(""),
                    );
                }
                rest = rest.get(end + 1..).unwrap_or("");
            }
        }
    }
    true
}

/// The plural category of `r.value` for `locale` with `Intl.PluralRules`
/// (the request's digit options and type); `None` when the engine rejects
/// them.
fn plural(locale: &str, r: &NumberRequest<'_>) -> Option<Category> {
    let mut j = Json::new(locale);
    if r.ordinal {
        j.text("type", "ordinal");
    }
    digits(&r.digits, Some((0, 3)), &mut j);
    let key = j.finish()?;
    let c = mf2_pr(key, r.value);
    // 0..=5 fit a u8.
    #[allow(clippy::cast_possible_truncation)]
    (c < 6).then(|| Category::from_code(c as u8))
}