@barefootjs/jsx 0.24.1 → 0.26.0

package/src/rich-type-refusal.ts

@@ -99,10 +99,11 @@ function pushDiagnostic(
   // `toLocaleDateString` has a catalogued explicit-input form (#2324 slice
   // 2) — point the fix at it instead of the generic escape hatches alone.
   // The implicit-environment forms (zero-arg, locale-only, non-literal
-  // locale, IANA timeZone) stay refused by design.
+  // locale, an unverifiable timeZone literal) stay refused by design;
+  // canonical IANA zone literals compile since #2344.
   const suggestion =
     method === 'toLocaleDateString' && typeName === 'Date'
-      ? "Pass a literal locale and an explicit literal timeZone — .toLocaleDateString('ja-JP', { timeZone: 'UTC' }) (or a fixed '±HH:MM' offset) — to compile it to the format_date helper; for a runtime locale, resolve the pattern in your i18n layer and use formatDate(date, pattern, tz) from @barefootjs/client. Alternatively add /* @client */ or pre-compute server-side."
+      ? "Pass a literal locale and an explicit literal timeZone — .toLocaleDateString('ja-JP', { timeZone: 'UTC' }), a fixed '±HH:MM' offset, or a canonical IANA zone ID like 'Asia/Tokyo' (exact case; #2344) — to compile it to the format_date helper; for a runtime locale, resolve the pattern in your i18n layer and use formatDate(date, pattern, tz) from @barefootjs/client. Alternatively add /* @client */ or pre-compute server-side."
       : 'Add /* @client */ to evaluate this expression on the client only, or pre-compute the value server-side.'
   errors.push({
     code: ErrorCodes.UNSUPPORTED_JSX_PATTERN,

package/src/to-locale-date-lowering.ts

@@ -34,8 +34,15 @@
  *     there, feeding `formatDate` directly. An OPTIONAL union prop also
  *     declines: `undefined` at runtime makes real `toLocaleDateString` read
  *     the host locale, which no frozen pattern table can reproduce;
- *   - an IANA `timeZone` name — couples output to the host's tzdata version
- *     (only `'UTC'` and fixed `±HH:MM` offsets are deterministic);
+ *   - an IANA `timeZone` literal the build machine cannot verify (#2344):
+ *     a named zone IS admitted when the build's own `Intl` echoes it back
+ *     verbatim from `resolvedOptions().timeZone` — the canonical primary
+ *     ID, the one spelling every backend's tzdata resolves identically (the
+ *     runtime helpers resolve it through Go `time.LoadLocation`, Ruby
+ *     tzinfo, PHP `DateTimeZone`, Perl `DateTime::TimeZone`, Python
+ *     `zoneinfo`, Rust `chrono-tz`). Non-canonical case, link/alias names
+ *     the probe canonicalizes away, and unknown zones all decline — the
+ *     probe-and-verify discipline of #2334, applied to tz;
  *   - an options bag the probe cannot reproduce EXACTLY in the token+table
  *     vocabulary — era, dayPeriod, 2-digit year, narrow name forms,
  *     non-literal option values ("faithful or loud", never approximate);
@@ -57,17 +64,46 @@ import { resolveReceiverType, baseTypeName } from './rich-type-evidence.ts'
 import { typeReachesDate } from './date-lowering.ts'
 
 /**
- * `timeZone` literals the lowering admits: `'UTC'` or a fixed `±HH:MM`
- * offset **within ECMA-402's valid offset range** (hours 00–23, minutes
- * 00–59). An out-of-range shape like `'+25:00'` or `'+99:99'` must DECLINE
- * (→ BF021), not lower: real `toLocaleDateString` throws a RangeError on
- * it, so compiling it would render a nonsense offset on the template
- * adapters while the JS-native path (Hono, and the pre-rewrite semantics
- * the sugar stands in for) crashes — the exact divergence the sugar exists
- * to rule out.
+ * `timeZone` literals the lowering admits without probing: `'UTC'` or a
+ * fixed `±HH:MM` offset **within ECMA-402's valid offset range** (hours
+ * 00–23, minutes 00–59). An out-of-range shape like `'+25:00'` or
+ * `'+99:99'` must DECLINE (→ BF021), not lower: real `toLocaleDateString`
+ * throws a RangeError on it, so compiling it would render a nonsense
+ * offset on the template adapters while the JS-native path (Hono, and the
+ * pre-rewrite semantics the sugar stands in for) crashes — the exact
+ * divergence the sugar exists to rule out. Named IANA zones are admitted
+ * through {@link isBuildResolvableTimeZone} instead (#2344).
  */
 export const TO_LOCALE_TZ_RE = /^(?:UTC|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/
 
+/** Build-time probe cache: tz literal → verified-canonical? */
+const tzProbeCache = new Map<string, boolean>()
+
+/**
+ * Probe-and-verify a named-zone `timeZone` literal against the build
+ * machine's own `Intl` (#2344, the #2334 discipline applied to tz): admit
+ * it iff `resolvedOptions().timeZone` echoes the literal back VERBATIM.
+ * The echo check is what pins the canonical primary IANA ID — `Intl`
+ * itself accepts case-folded spellings and link/alias names but
+ * canonicalizes them in `resolvedOptions()`, and those non-canonical
+ * spellings are exactly where backend tzdata layers disagree (Go/Python/
+ * Ruby/Rust resolve the exact ID set; PHP folds case; link availability
+ * varies by tzdata vintage). Anything the probe can't verify declines
+ * (→ BF021) — the `formatDate` primitive stays available for edge cases.
+ */
+export function isBuildResolvableTimeZone(value: string): boolean {
+  const cached = tzProbeCache.get(value)
+  if (cached !== undefined) return cached
+  let verified: boolean
+  try {
+    verified = new Intl.DateTimeFormat('en-US', { timeZone: value }).resolvedOptions().timeZone === value
+  } catch {
+    verified = false
+  }
+  tzProbeCache.set(value, verified)
+  return verified
+}
+
 /**
  * Probe instant for pattern derivation: 2001-02-03 UTC. Month and day are
  * distinct single-digit values, so the rendered part text distinguishes both
@@ -452,8 +488,9 @@ export function matchToLocaleDateStringCall(
   if (callee.kind !== 'member' || callee.computed) return null
   if (callee.property !== 'toLocaleDateString' || args.length !== 2) return null
   const [locale, options] = args
-  // Options bag: `timeZone` is REQUIRED (a literal 'UTC' | valid ±HH:MM —
-  // its omission would read the host timezone); every OTHER key rides into
+  // Options bag: `timeZone` is REQUIRED (a literal 'UTC' | valid ±HH:MM |
+  // probe-verified canonical IANA zone (#2344) — its omission would read
+  // the host timezone); every OTHER key rides into
   // the Intl probe as-is when its value is a string literal (#2334's
   // fidelity rule: admit any literal options bag the probe can reproduce
   // exactly, decline everything else — dateStyle, month/weekday forms, …).
@@ -464,7 +501,7 @@ export function matchToLocaleDateStringCall(
     if (prop.value.kind !== 'literal' || prop.value.literalType !== 'string') return null
     const value = String(prop.value.value)
     if (prop.key === 'timeZone') {
-      if (!TO_LOCALE_TZ_RE.test(value)) return null
+      if (!TO_LOCALE_TZ_RE.test(value) && !isBuildResolvableTimeZone(value)) return null
       tz = value
     } else {
       probeOptions[prop.key] = value

package/src/types.ts

@@ -1455,6 +1455,19 @@ export interface NamedExportSpecifier {
   isTypeOnly: boolean
 }
 
+/** One identifier occurrence in a factory body that call-site inlining may
+ *  rename (#2341 BUG-1). Offsets are relative to ReactiveFactoryInfo.bodySource. */
+export interface FactoryRenameSite {
+  name: string
+  start: number
+  end: number
+  /** 'shorthand' = the identifier is simultaneously a property key and a
+   *  value/binding reference ({ name } literal, or { name } object-pattern
+   *  element). Renaming it must EXPAND to `name: <replacement>` to preserve
+   *  the key. 'plain' = ordinary reference or declaration name. */
+  form: 'plain' | 'shorthand'
+}
+
 /**
  * Reactive factory helper metadata (#931). Collected when a same-file
  * function matches the factory shape: exactly one top-level `return` whose
@@ -1500,14 +1513,23 @@ export interface ReactiveFactoryInfo {
    * file are dropped at prescan time.
    */
   requiredImports?: RequiredFactoryImport[]
+  /**
+   * Identifier occurrences within `bodySource` that call-site inlining may
+   * rename (#2341 BUG-1) — collected by the same AST walk that produces
+   * `bodySource`, so offsets stay in lockstep with the serialized text.
+   * Same-file and cross-file factories both get this (both flow through
+   * `detectReactiveFactory`).
+   */
+  renameSites: FactoryRenameSite[]
 }
 
 /**
  * An import the helper file holds that an inlined factory body references
- * (#2332). Not a BF112 capture: the component file can import the same
- * binding itself. Collected at prescan with the specifier ALREADY rewritten
- * relative to the component file (or unchanged for bare/npm specifiers);
- * the source rewriter injects one deduped import statement per specifier.
+ * (#2332, type-only refs added #2350). Not a BF112 capture: the component
+ * file can import the same binding itself. Collected at prescan with the
+ * specifier ALREADY rewritten relative to the component file (or unchanged
+ * for bare/npm specifiers); the source rewriter injects one deduped import
+ * statement per (specifier, isTypeOnly) pair.
  */
 export interface RequiredFactoryImport {
   /** Local binding name as referenced inside the factory body. */
@@ -1516,6 +1538,9 @@ export interface RequiredFactoryImport {
   exportedName: string
   /** Component-file-relative specifier (`../lib/mathmod`), or the unchanged bare specifier. */
   specifier: string
+  /** True when the factory body only ever references this in type position —
+   *  re-provisioned as `import type { ... }` instead of a value import. */
+  isTypeOnly?: boolean
 }
 
 /**
@@ -1526,7 +1551,7 @@ export interface RequiredFactoryImport {
  * the generic BF110.
  */
 export interface DeclinedReactiveFactory {
-  code: 'BF111' | 'BF112' | 'BF113'
+  code: 'BF111' | 'BF112' | 'BF113' | 'BF114'
   /** Detail spliced into the call-site message (e.g. offending identifier list). */
   detail: string
   /** Definition site (in the helper file for cross-file declines). */