@barefootjs/rust 0.21.4 → 0.24.1

package/dist/index.js

@@ -189190,18 +189190,18 @@ var minijinjaAdapter = new MinijinjaAdapter;
 // src/conformance-pins.ts
 var conformancePins = {
   "static-array-from-props": [
-    { code: "BF101", severity: "error", issue: "https://github.com/piconic-ai/barefootjs/issues/2087" }
+    { code: "BF101", severity: "error", issue: "https://github.com/piconic-ai/barefootjs/issues/2321" }
   ],
   "static-array-from-props-with-component": [
-    { code: "BF101", severity: "error", issue: "https://github.com/piconic-ai/barefootjs/issues/2087" }
+    { code: "BF101", severity: "error", issue: "https://github.com/piconic-ai/barefootjs/issues/2321" }
   ],
   "filter-nested-callback-predicate": [
-    { code: "BF101", severity: "error", issue: "https://github.com/piconic-ai/barefootjs/issues/2038" }
+    { code: "BF101", severity: "error", issue: "https://github.com/piconic-ai/barefootjs/issues/2320" }
   ],
   "filter-nested-find-predicate": [
-    { code: "BF101", severity: "error", issue: "https://github.com/piconic-ai/barefootjs/issues/2038" }
+    { code: "BF101", severity: "error", issue: "https://github.com/piconic-ai/barefootjs/issues/2320" }
   ],
-  "dangerous-inner-html-dynamic": [{ code: "BF101", severity: "error", issue: "https://github.com/piconic-ai/barefootjs/issues/2215" }],
+  "dangerous-inner-html-dynamic": [{ code: "BF101", severity: "error", issue: "https://github.com/piconic-ai/barefootjs/issues/2319" }],
   "date-method-uncatalogued": [{ code: "BF021", severity: "error", issue: "https://github.com/piconic-ai/barefootjs/issues/2274" }]
 };
 // src/render-divergences.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/rust",
-  "version": "0.21.4",
+  "version": "0.24.1",
   "description": "minijinja (Rust) adapter for BarefootJS — compiles IR to .j2 templates and ships a Rust rendering runtime (packages/adapter-rust/runtime/); runs under any Rust web framework (axum, etc.)",
   "type": "module",
   "main": "./dist/index.js",
@@ -54,14 +54,14 @@
     "directory": "packages/adapter-rust"
   },
   "dependencies": {
-    "@barefootjs/shared": "0.21.4"
+    "@barefootjs/shared": "0.24.1"
   },
   "peerDependencies": {
     "@barefootjs/jsx": ">=0.2.0"
   },
   "devDependencies": {
     "@barefootjs/adapter-tests": "0.1.0",
-    "@barefootjs/jsx": "0.21.4",
+    "@barefootjs/jsx": "0.24.1",
     "typescript": "^5.0.0"
   }
 }

package/runtime/src/date.rs

@@ -161,6 +161,152 @@ pub fn date(recv: &JsValue, op: &str) -> JsValue {
     }
 }
 
+/// Parse a fixed UTC offset `tz` matching `^([+-])(\d{2}):(\d{2})$` into
+/// signed minutes -- mirrors `OFFSET_RE` in
+/// `packages/client/src/format-date.ts` and `tzOffsetRE` in the Go
+/// runtime's `bf.go`. ANY other shape (`"UTC"`, an IANA zone name, a
+/// malformed offset like `"+9:00"`) is not this exact 6-byte
+/// sign/digit/digit/colon/digit/digit layout and normalizes to `0`
+/// minutes (UTC) -- byte/ascii-digit checks here, not a `regex` crate
+/// dependency (this crate's fixed dependency list excludes `regex`, same
+/// as this module's docstring notes for `chrono`).
+fn parse_tz_offset(tz: &str) -> i64 {
+    let b = tz.as_bytes();
+    if b.len() != 6 || b[3] != b':' {
+        return 0;
+    }
+    let sign = match b[0] {
+        b'+' => 1i64,
+        b'-' => -1i64,
+        _ => return 0,
+    };
+    if !b[1].is_ascii_digit() || !b[2].is_ascii_digit() || !b[4].is_ascii_digit() || !b[5].is_ascii_digit() {
+        return 0;
+    }
+    let hh = (b[1] - b'0') as i64 * 10 + (b[2] - b'0') as i64;
+    let mm = (b[4] - b'0') as i64 * 10 + (b[5] - b'0') as i64;
+    sign * (hh * 60 + mm)
+}
+
+/// `names`-table section offsets (#2334, mirrors `MONTHS_WIDE` /
+/// `MONTHS_ABBR` / `WEEKDAYS_WIDE` / `WEEKDAYS_ABBR` in
+/// `packages/client/src/format-date.ts` and the Go runtime's `bf.go`
+/// `monthsWide` / `monthsAbbr` / `weekdaysWide` / `weekdaysAbbr` constants).
+const MONTHS_WIDE: usize = 0;
+const MONTHS_ABBR: usize = 12;
+const WEEKDAYS_WIDE: usize = 24;
+const WEEKDAYS_ABBR: usize = 31;
+
+/// Read one `names` table entry (#2334): `names` is the runtime's own
+/// [`JsValue`] array value (whatever array shape `bf.arr`-equivalent
+/// template output materializes into -- see [`crate::runtime::mj_to_js`]'s
+/// `Seq`/`Iterable` arm, which is what a compiled minijinja template's
+/// 4th `format_date` argument becomes by the time it reaches here). A
+/// missing/out-of-range index, a non-array `names`, or a non-string
+/// element all render `""` -- the same total, zero-value discipline as an
+/// unparseable date, mirroring `names[index] ?? ''` in the JS reference
+/// (`packages/client/src/format-date.ts`'s `nameAt`) and `formatDateName`
+/// in the Go runtime's `bf.go`.
+fn name_at(names: &JsValue, index: usize) -> &str {
+    match names.as_array().and_then(|arr| arr.get(index)) {
+        Some(JsValue::String(s)) => s.as_str(),
+        _ => "",
+    }
+}
+
+/// `format_date(recv, pattern, tz, names)` -- the lowering target for a
+/// `formatDate(date, pattern, timeZone, names)` call
+/// (spec/template-helpers.md "format_date", #2324, #2334): a total,
+/// deterministic date-pattern formatter -- no locale, no host timezone, no
+/// `SystemTime::now`. Mirrors `packages/client/src/format-date.ts` (the
+/// JS-normative reference) and the Go runtime's `FormatDate` byte-for-byte.
+///
+/// `recv` follows the `date` helper's receiver contract exactly (see
+/// [`epoch_ms_of`]): this runtime's own [`JsValue::Date`] or an ISO-8601
+/// string, both normalized to a single epoch-ms instant. A `None`
+/// (nil/unset or unparseable) receiver renders `""` -- unlike [`date`],
+/// there is no accessor/`getTime` numeric fallback here, since
+/// `format_date` always returns a string.
+///
+/// `tz` resolves via [`parse_tz_offset`]; the instant is shifted by
+/// `offset_minutes * 60_000` ms and the shifted instant's UTC calendar
+/// fields (not the original instant's) are what the pattern tokens read --
+/// the shifted UTC clock face IS the local clock face at that offset.
+///
+/// `names` (#2334) is a flat table in fixed layout: `[0..11]` wide month
+/// names, `[12..23]` abbreviated month names, `[24..30]` wide weekday names
+/// (Sunday-first), `[31..37]` abbreviated weekday names -- see [`name_at`].
+/// The caller owns the values (locale selection is not this function's
+/// job); this only indexes the table.
+///
+/// `pattern` is scanned left-to-right, longest-match, for the token set
+/// `YYYY|MMMM|MMM|MM|DD|dddd|ddd|M|D` (checking longer tokens before
+/// shorter ones at each position, the same alternation-order discipline the
+/// Go/JS ports use); every other character -- including multi-byte ones
+/// like 年/月/日 or 月-name table values -- passes through/renders
+/// literally. The scan advances by whole characters only (ASCII token
+/// matches consume exactly 1/2/4 ASCII bytes; the fallback branch consumes
+/// one full `char` via `len_utf8`), so slicing never lands mid-codepoint.
+/// `YYYY` is `abs(year)` zero-padded to 4 digits, `-`-prefixed for a
+/// negative year; `MM`/`DD` zero-pad to 2; `M`/`D` are bare. `MMMM`/`MMM`
+/// read `names[month-1]` / `names[12+month-1]`; `dddd`/`ddd` read
+/// `names[24+weekday]` / `names[31+weekday]`, where `weekday` (0 = Sunday)
+/// is derived from the shifted epoch day count via
+/// `(days + 4).rem_euclid(7)` -- 1970-01-01 (`days == 0`) is a Thursday,
+/// and `rem_euclid` (not `%`, which truncates toward zero in Rust) keeps
+/// the result in `[0, 6]` for a negative (pre-1970) `days` too.
+pub fn format_date(recv: &JsValue, pattern: &str, tz: &str, names: &JsValue) -> String {
+    let ms = match epoch_ms_of(recv) {
+        Some(ms) => ms,
+        None => return String::new(),
+    };
+    let offset_minutes = parse_tz_offset(tz);
+    let shifted = ms + offset_minutes * 60_000;
+    let days = shifted.div_euclid(MS_PER_DAY);
+    let (year, month, day) = civil_from_days(days);
+    let yyyy = if year < 0 { format!("-{:04}", -year) } else { format!("{year:04}") };
+    let weekday = (days + 4).rem_euclid(7) as usize; // 0 = Sunday; epoch (days=0) is Thursday
+
+    let mut out = String::with_capacity(pattern.len());
+    let mut i = 0;
+    while i < pattern.len() {
+        let rest = &pattern[i..];
+        if rest.starts_with("YYYY") {
+            out.push_str(&yyyy);
+            i += 4;
+        } else if rest.starts_with("MMMM") {
+            out.push_str(name_at(names, MONTHS_WIDE + (month - 1) as usize));
+            i += 4;
+        } else if rest.starts_with("MMM") {
+            out.push_str(name_at(names, MONTHS_ABBR + (month - 1) as usize));
+            i += 3;
+        } else if rest.starts_with("MM") {
+            out.push_str(&format!("{month:02}"));
+            i += 2;
+        } else if rest.starts_with("DD") {
+            out.push_str(&format!("{day:02}"));
+            i += 2;
+        } else if rest.starts_with("dddd") {
+            out.push_str(name_at(names, WEEKDAYS_WIDE + weekday));
+            i += 4;
+        } else if rest.starts_with("ddd") {
+            out.push_str(name_at(names, WEEKDAYS_ABBR + weekday));
+            i += 3;
+        } else if rest.starts_with('M') {
+            out.push_str(&month.to_string());
+            i += 1;
+        } else if rest.starts_with('D') {
+            out.push_str(&day.to_string());
+            i += 1;
+        } else {
+            let ch = rest.chars().next().expect("i < pattern.len() guarantees a char remains");
+            out.push(ch);
+            i += ch.len_utf8();
+        }
+    }
+    out
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

package/runtime/src/runtime.rs

@@ -1338,6 +1338,16 @@ impl Object for BfInstance {
             // string; `date::date` normalizes and dispatches both. `op`
             // stays a plain string arg, never routed through `js_number`.
             "date" => Ok(js_to_mj(&date::date(a(0), a(1).as_str().unwrap_or("")))),
+            // `format_date(recv, pattern, tz, names)` (spec/template-helpers.md
+            // "format_date", #2324, #2334) -- total, locale-free date-pattern
+            // formatting layered on the same `recv` normalization as
+            // `date` above. `names` stays the array-shaped `JsValue` that
+            // `mj_to_js`'s `Seq`/`Iterable` arm already produced above (the
+            // compiler's lowering always passes 4 args); a non-array or
+            // missing `names` degrades to `""` for every name token, per
+            // `date::name_at`. See `date::format_date`'s docstring for the
+            // full contract.
+            "format_date" => Ok(MjValue::from(date::format_date(a(0), a(1).as_str().unwrap_or(""), a(2).as_str().unwrap_or(""), a(3)))),
 
             // -- Array / string method helpers (#1448 Tier A) ------------------
             "includes" => Ok(MjValue::from(includes(a(0), a(1)))),

package/runtime/tests/helper_vectors.rs

@@ -150,6 +150,7 @@ fn call_binding(fn_name: &str, args: &[JsValue]) -> Option<JsValue> {
             JsValue::String(num::to_fixed(runtime::js_number(&a(0)), digits))
         }
         "date" => date::date(&a(0), a(1).as_str().unwrap_or("")),
+        "format_date" => JsValue::String(date::format_date(&a(0), a(1).as_str().unwrap_or(""), a(2).as_str().unwrap_or(""), &a(3))),
         "lower" => JsValue::String(runtime::js_string(&a(0)).to_lowercase()),
         "upper" => JsValue::String(runtime::js_string(&a(0)).to_uppercase()),
         "trim" => JsValue::String(runtime::trim(&a(0))),

package/src/conformance-pins.ts

@@ -42,15 +42,15 @@ export const conformancePins: ConformancePins = {
   // diagnostic (mirrors adapter-jinja's identical check). Fixing the
   // underlying gap (computed-array-from-props as a loop source) is out of
   // scope for #2087; tracked as a follow-up at
-  // https://github.com/piconic-ai/barefootjs/issues/2087.
+  // https://github.com/piconic-ai/barefootjs/issues/2321.
   'static-array-from-props': [
-    { code: 'BF101', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2087' },
+    { code: 'BF101', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2321' },
   ],
   // BF101 (unresolvable computed loop array, see above) fires; BF103
   // (imported child in the loop body) no longer does now that the
   // conformance harness passes `siblingTemplatesRegistered: true` (#2205).
   'static-array-from-props-with-component': [
-    { code: 'BF101', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2087' },
+    { code: 'BF101', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2321' },
   ],
   // Rest-destructure `.map()` callbacks (#2087 Phase B): every shape now
   // lowers natively — fixed bindings at any depth/shape via a chained
@@ -80,12 +80,12 @@ export const conformancePins: ConformancePins = {
   // lossy, same as xslate. The `/* @client */` twin
   // (`filter-nested-callback-predicate-client`) has no pin here: it must
   // render clean on every adapter, which asserts the suppression contract.
-  // https://github.com/piconic-ai/barefootjs/issues/2038
+  // Faithful lowering tracked: https://github.com/piconic-ai/barefootjs/issues/2320 (successor to #2038)
   'filter-nested-callback-predicate': [
-    { code: 'BF101', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2038' },
+    { code: 'BF101', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2320' },
   ],
   'filter-nested-find-predicate': [
-    { code: 'BF101', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2038' },
+    { code: 'BF101', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2320' },
   ],
   // NB: TOP-LEVEL `.find` / `.findIndex` / `.findLast` / `.findLastIndex`
   // (text position) are NOT pinned here — like xslate (unlike mojo, which
@@ -101,8 +101,8 @@ export const conformancePins: ConformancePins = {
   // `dangerouslySetInnerHTML={{ __html: '...' }}` is spliced directly into
   // the template as trusted raw text (`resolveDangerousInnerHtml`, #2207).
   // A dynamic/signal-derived value still refuses with BF101 — see the
-  // `dangerous-inner-html-dynamic` fixture/pin below (tracked: #2215).
-  'dangerous-inner-html-dynamic': [{ code: 'BF101', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2215' }],
+  // `dangerous-inner-html-dynamic` fixture/pin below (tracked: #2319, successor to #2215).
+  'dangerous-inner-html-dynamic': [{ code: 'BF101', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2319' }],
   // #2273: a method call on a prop typed as a built-in host rich type
   // (Date, Map, …) has no catalogued lowering in any adapter — this is a
   // compiler-level refusal (`checkRichTypeMethodCalls`, wired ahead of