@aircloudhq/web 1.0.0

package/src/i18n/index.js

@@ -0,0 +1,373 @@
+// The i18n runtime (ADR-223 D6; spec S4 § Translation semantics): `t`, `l`, number formatting and
+// `pluralize` over a locale bundle (contracts/deploy/v1/locale-bundle-v1.json) and NOTHING else —
+// never the host's Intl or time-zone database (D4). Every behaviour here is pinned by the shared
+// vectors (contracts/deploy/v1/i18n-vectors.json), which the Rust function runtime runs too.
+import { abs, delimit, parseDecimal, roundFixed, roundSignificant } from './decimal.js';
+import { pluralCategory } from './plural.js';
+import { civilFromDays, daysFromCivil, floorDiv, weekdayOf } from './civil.js';
+import { strftime } from './strftime.js';
+import { zoneAt } from './zone.js';
+
+export { pluralCategory, operands } from './plural.js';
+export { zoneAt } from './zone.js';
+export { negotiateLocale, lookupLocale, acceptLanguage, localeFromUrl } from './negotiate.js';
+export { createMissingReporter } from './missing.js';
+
+/** The locale that ends every run-time chain with the platform defaults (S4 § [i18n]). */
+export const PLATFORM_TERMINAL_LOCALE = 'en';
+
+const PLURAL_KEYS = ['zero', 'one', 'two', 'few', 'many', 'other'];
+const OPTION_KEYS = new Set(['scope', 'default', 'count', 'lazy', 'context', 'locale']);
+
+// ── chains ───────────────────────────────────────────────────────────────────────────────────
+
+/** The run-time chain: the locale, its declared fallbacks, default_locale, then `en`. */
+export function runtimeChain(bundle, locale) {
+  return unique([locale, ...(bundle.fallbacks?.[locale] ?? []), bundle.default_locale, PLATFORM_TERMINAL_LOCALE]);
+}
+
+/** The locale and its declared fallbacks — where names, number symbols and inflections resolve. */
+export function declaredChain(bundle, locale) {
+  return unique([locale, ...(bundle.fallbacks?.[locale] ?? [])]);
+}
+
+function unique(list) {
+  return [...new Set(list.filter(Boolean))];
+}
+
+function dig(tree, parts) {
+  let cur = tree;
+  for (const p of parts) {
+    if (cur === null || typeof cur !== 'object' || Array.isArray(cur) || !(p in cur)) return undefined;
+    cur = cur[p];
+  }
+  return cur;
+}
+
+function parts(key) {
+  return String(key).split('.').filter((s) => s !== '');
+}
+
+function firstIn(bundle, locales, key, accept = (v) => v !== undefined && v !== null) {
+  for (const loc of locales) {
+    const v = dig(bundle.messages?.[loc], parts(key));
+    if (accept(v)) return { value: v, locale: loc };
+  }
+  return undefined;
+}
+
+const isObject = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
+
+// ── keys ─────────────────────────────────────────────────────────────────────────────────────
+
+/** The key scope of a lazy lookup: a site page path or a function name (S4 § Locale files). */
+export function lazyScope(lazy) {
+  if (!lazy) return undefined;
+  if (lazy.site_page) {
+    const p = lazy.site_page.replace(/^(app\/site\/)?(src\/)?pages\//, '').replace(/\.(jsx|js)$/, '');
+    return p.split('/').filter(Boolean).join('.');
+  }
+  if (lazy.function) return `functions.${lazy.function}`;
+  return undefined;
+}
+
+/** A key with its scope and lazy prefix applied. */
+export function expandKey(key, { scope, lazy } = {}) {
+  const k = String(key);
+  if (k.startsWith('.')) {
+    const s = lazyScope(lazy);
+    if (!s) throw new Error(`t("${k}"): a lazy key needs a page or function scope`);
+    return `${s}${k}`;
+  }
+  const sc = Array.isArray(scope) ? scope.join('.') : scope;
+  return sc ? `${sc}.${k}` : k;
+}
+
+/** Rails' humanize of the last key segment — the published rendering of a missing key (D10). */
+export function humanizeKey(key) {
+  const seg = parts(key).pop() ?? String(key);
+  let s = seg.replace(/^_+/, '');
+  if (s.endsWith('_id')) s = s.slice(0, -3);
+  s = s.replace(/_/g, ' ').replace(/[A-Za-z0-9]+/g, (w) => w.toLowerCase()).trim();
+  return s.replace(/^[a-z]/, (c) => c.toUpperCase());
+}
+
+// ── t ────────────────────────────────────────────────────────────────────────────────────────
+
+const ESCAPES = { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' };
+
+/** ERB::Util.html_escape. */
+export function escapeHtml(s) {
+  return String(s).replace(/[&<>"']/g, (c) => ESCAPES[c]);
+}
+
+/** Whether a key's translation may carry markup (Rails: the key ends in `_html` or `.html`). */
+export function isHtmlKey(key) {
+  return /(?:_|\.|^)html$/.test(String(key));
+}
+
+/** `%{name}` interpolation; `%%` is a literal percent; a missing argument keeps its placeholder. */
+export function interpolate(text, args, escape = (v) => String(v)) {
+  return String(text).replace(/%%|%\{([^}]+)\}/g, (m, name) => {
+    if (m === '%%') return '%';
+    return Object.prototype.hasOwnProperty.call(args, name) && args[name] !== undefined ? escape(args[name]) : m;
+  });
+}
+
+function pluralize(bundle, locale, entry, count) {
+  if (!isObject(entry) || !PLURAL_KEYS.some((k) => k in entry)) return entry;
+  if (Number(parseFloat(String(count))) === 0 && 'zero' in entry) return entry.zero;
+  const cats = bundle.cldr?.[locale]?.plurals;
+  const cat = cats ? pluralCategory(cats, count) : 'other';
+  return cat in entry ? entry[cat] : entry.other;
+}
+
+/**
+ * Resolve a translation: per locale of the run-time chain, the key then its key defaults; a literal
+ * default only after the whole chain (Rails' Fallbacks backend).
+ * @returns {{found: true, value: any, literal?: boolean} | {found: false, key: string}}
+ */
+export function resolve(bundle, locale, key, options = {}) {
+  const fullKey = expandKey(key, options);
+  const defaults = options.default === undefined ? [] : Array.isArray(options.default) ? options.default : [options.default];
+  const keyDefaults = defaults.filter(isObject).map((d) => expandKey(d.key, options));
+  const literal = defaults.find((d) => typeof d === 'string');
+  for (const loc of runtimeChain(bundle, locale)) {
+    for (const k of [fullKey, ...keyDefaults]) {
+      let v = dig(bundle.messages?.[loc], parts(k));
+      if (v === undefined || v === null) continue;
+      if (options.count !== undefined) v = pluralize(bundle, loc, v, options.count);
+      if (v === undefined || v === null) continue;
+      return { found: true, value: v, key: fullKey };
+    }
+  }
+  if (literal !== undefined) return { found: true, value: literal, literal: true, key: fullKey };
+  return { found: false, key: fullKey };
+}
+
+/**
+ * `t`: the rendered translation in the output context (`html` escapes interpolated values, and the
+ * translation text unless the key may carry markup; `text` and `json` escape nothing).
+ */
+export function translate(bundle, locale, key, options = {}, report = () => {}) {
+  const context = options.context ?? 'text';
+  const args = {};
+  for (const [k, v] of Object.entries(options)) if (!OPTION_KEYS.has(k)) args[k] = v;
+  if (options.count !== undefined) args.count = options.count;
+  const r = resolve(bundle, locale, key, options);
+  if (!r.found) {
+    report(r.key);
+    const h = humanizeKey(r.key);
+    return context === 'html' ? escapeHtml(h) : h;
+  }
+  if (typeof r.value !== 'string') return r.value;
+  if (context !== 'html') return interpolate(r.value, args);
+  if (isHtmlKey(r.key)) return interpolate(r.value, args, escapeHtml);
+  return escapeHtml(interpolate(r.value, args));
+}
+
+// ── l ────────────────────────────────────────────────────────────────────────────────────────
+
+const CIVIL = /^(\d{4})-(\d{2})-(\d{2})$/;
+
+/** The locale's value for a name kind: its declared chain's messages, then its CLDR data. */
+function nameSource(bundle, locale) {
+  const keys = {
+    day_names: 'date.day_names', abbr_day_names: 'date.abbr_day_names',
+    month_names: 'date.month_names', abbr_month_names: 'date.abbr_month_names',
+    am: 'time.am', pm: 'time.pm',
+  };
+  return (kind) => {
+    const hit = firstIn(bundle, declaredChain(bundle, locale), keys[kind]);
+    if (hit) return hit.value;
+    const cldr = bundle.cldr?.[locale]?.dates?.[kind];
+    if (cldr !== undefined) return cldr;
+    throw new Error(`no ${kind} for ${locale} in the bundle`);
+  };
+}
+
+/** Break a value down to local time: a civil date string, or an instant rendered in `zone`. */
+export function brokenDown(bundle, value, zoneName) {
+  if (typeof value === 'string' && CIVIL.test(value)) {
+    const [, y, m, d] = CIVIL.exec(value).map(Number);
+    return { kind: 'date', year: y, month: m, day: d, hour: 0, minute: 0, second: 0, wday: weekdayOf(daysFromCivil(y, m, d)), offset: null, abbr: null };
+  }
+  const ms = value instanceof Date ? value.getTime() : typeof value === 'number' ? value : Date.parse(value);
+  if (!Number.isFinite(ms)) throw new RangeError(`l: not a date or time: ${value}`);
+  const name = zoneName ?? bundle.time_zone;
+  const zone = bundle.zones?.[name];
+  if (!zone) throw new Error(`l: the bundle carries no rules for the zone ${name}`);
+  const at = Math.floor(ms / 1000);
+  const lt = zoneAt(zone, at);
+  const local = at + lt.offset;
+  const days = floorDiv(local, 86400);
+  const [year, month, day] = civilFromDays(days);
+  const sod = local - days * 86400;
+  return {
+    kind: 'time', year, month, day,
+    hour: Math.floor(sod / 3600), minute: Math.floor((sod % 3600) / 60), second: sod % 60,
+    wday: weekdayOf(days), offset: lt.offset, abbr: lt.abbr,
+  };
+}
+
+/** `l`: a date or time in a named format (date.formats / time.formats) or a strftime string. */
+export function localize(bundle, locale, value, options = {}, report = () => {}) {
+  const t = brokenDown(bundle, value, options.zone);
+  const format = options.format ?? 'default';
+  let pattern = format;
+  if (!String(format).includes('%')) {
+    const key = `${t.kind}.formats.${format}`;
+    const hit = firstIn(bundle, runtimeChain(bundle, locale), key, (v) => typeof v === 'string');
+    if (!hit) {
+      report(key);
+      return humanizeKey(key);
+    }
+    pattern = hit.value;
+  }
+  return strftime(pattern, t, nameSource(bundle, locale));
+}
+
+// ── numbers ──────────────────────────────────────────────────────────────────────────────────
+
+/** ActiveSupport::NumberHelper::NumberConverter::DEFAULTS. */
+export const NUMBER_DEFAULTS = {
+  format: { separator: '.', delimiter: ',', precision: 3, significant: false, strip_insignificant_zeros: false },
+  currency: { format: '%u%n', negative_format: '-%u%n', unit: '$', separator: '.', delimiter: ',', precision: 2, significant: false, strip_insignificant_zeros: false },
+  percentage: { delimiter: '', format: '%n%' },
+  precision: { delimiter: '' },
+  human: {
+    delimiter: '', precision: 3, significant: true, strip_insignificant_zeros: true,
+    units: { billion: 'Billion', million: 'Million', quadrillion: 'Quadrillion', thousand: 'Thousand', trillion: 'Trillion', unit: '' },
+  },
+  storage_units: { format: '%n %u', units: { byte: 'Bytes', kb: 'KB', mb: 'MB', gb: 'GB', tb: 'TB', pb: 'PB', eb: 'EB', zb: 'ZB' } },
+};
+
+/**
+ * The effective options of a number style (Rails' i18n_format_options): defaults, then the first
+ * `number.format` hash of the locale's declared chain (else its CLDR symbols), then the first
+ * `number.<namespace>.format` hash of the run-time chain, then the call's options.
+ */
+export function numberOptions(bundle, locale, namespace, options = {}) {
+  const base = firstIn(bundle, declaredChain(bundle, locale), 'number.format', isObject)?.value
+    ?? cldrNumberFormat(bundle, locale)
+    ?? firstIn(bundle, runtimeChain(bundle, locale), 'number.format', isObject)?.value
+    ?? {};
+  const ns = namespace ? firstIn(bundle, runtimeChain(bundle, locale), `number.${namespace}.format`, isObject)?.value ?? {} : {};
+  return { ...NUMBER_DEFAULTS.format, ...(namespace ? NUMBER_DEFAULTS[namespace] ?? {} : {}), ...base, ...ns, ...options };
+}
+
+function cldrNumberFormat(bundle, locale) {
+  const n = bundle.cldr?.[locale]?.numbers;
+  return n ? { separator: n.decimal, delimiter: n.group } : undefined;
+}
+
+/** number_with_delimiter over the given options. */
+export function formatDelimited(value, o) {
+  const d = parseDecimal(value);
+  return `${d.neg ? '-' : ''}${delimit(d.int, o.delimiter)}${d.frac ? o.separator + d.frac : ''}`;
+}
+
+/** number_with_precision over the given options (half-up rounding, BigDecimal's). */
+export function formatRounded(value, o) {
+  const d = parseDecimal(value);
+  const precision = Number(o.precision);
+  let r = o.significant && precision > 0 ? roundSignificant(d, precision) : roundFixed(d, precision);
+  let frac = r.frac;
+  if (o.strip_insignificant_zeros) frac = frac.replace(/0+$/, '');
+  return `${r.neg ? '-' : ''}${delimit(r.int, o.delimiter)}${frac ? o.separator + frac : ''}`;
+}
+
+/** The shared number styles: currency | delimited | precision | percentage. */
+export function formatNumber(bundle, locale, style, value, options = {}) {
+  switch (style) {
+    case 'delimited':
+      return formatDelimited(value, numberOptions(bundle, locale, null, options));
+    case 'precision':
+      return formatRounded(value, numberOptions(bundle, locale, 'precision', options));
+    case 'percentage': {
+      const o = numberOptions(bundle, locale, 'percentage', options);
+      return o.format.replace('%n', formatRounded(value, o));
+    }
+    case 'currency': {
+      const o = numberOptions(bundle, locale, 'currency', options);
+      const d = parseDecimal(value);
+      const rounded = formatRounded(abs(d), o);
+      const zero = /^[^1-9]*$/.test(rounded);
+      const format = d.neg && !zero ? o.negative_format : o.format;
+      return format.replace('%n', rounded).replace('%u', o.unit);
+    }
+    default:
+      throw new Error(`formatNumber: unknown style ${style}`);
+  }
+}
+
+// ── pluralize ────────────────────────────────────────────────────────────────────────────────
+
+/** A word's plural under the locale's inflections (its declared chain), Active Support's way. */
+export function inflectPlural(bundle, locale, word) {
+  if (!word) return word;
+  const inf = firstIn(bundle, declaredChain(bundle, locale), 'inflections', isObject)?.value;
+  if (!inf) return word;
+  const lower = word.toLowerCase();
+  // Active Support: /\b<word>\Z/i — the uncountable word ends the string after a word boundary.
+  for (const u of inf.uncountable ?? []) {
+    const ul = String(u).toLowerCase();
+    if (lower === ul || (lower.endsWith(ul) && /[^a-z0-9_]/.test(lower[lower.length - ul.length - 1] ?? ''))) return word;
+  }
+  for (const [singular, plural] of inf.irregular ?? []) {
+    // The irregular plural is already plural (Rails adds a rule for it too).
+    if (lower.endsWith(String(plural).toLowerCase())) return word;
+    if (lower.endsWith(String(singular).toLowerCase())) {
+      const at = word.length - singular.length;
+      const head = word[at];
+      const tail = String(plural);
+      return word.slice(0, at) + (head === head.toUpperCase() && head !== head.toLowerCase() ? tail[0].toUpperCase() : tail[0]) + tail.slice(1);
+    }
+  }
+  const rules = inf.plural ?? [];
+  for (let i = rules.length - 1; i >= 0; i -= 1) {
+    const [pattern, replacement] = rules[i];
+    const re = new RegExp(pattern, 'iu');
+    if (re.test(word)) return word.replace(re, String(replacement).replace(/\\(\d)/g, '$$$1'));
+  }
+  return word;
+}
+
+/** TextHelper#pluralize: the singular for a count of 1 (or 1.0…), else the plural. */
+export function pluralizeWord(bundle, locale, count, singular, plural) {
+  const one = count === 1 || /^1(\.0+)?$/.test(String(count));
+  const word = one ? singular : plural ?? inflectPlural(bundle, locale, singular);
+  return `${count ?? 0} ${word}`;
+}
+
+// ── the instance ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * An i18n instance bound to a bundle and a locale.
+ * @param {{bundle: object, locale?: string, reporter?: (key: string) => void, lazy?: object}} init
+ */
+export function createI18n({ bundle, locale, reporter, lazy } = {}) {
+  if (!bundle || bundle.version !== 1) throw new Error('createI18n: a locale bundle v1 is required');
+  const current = locale && bundle.available_locales.includes(locale) ? locale : bundle.default_locale;
+  const report = reporter ?? (() => {});
+  const self = {
+    bundle,
+    locale: current,
+    t: (key, options = {}) => translate(bundle, current, key, { lazy, ...options }, report),
+    l: (value, options = {}) => localize(bundle, current, value, options, report),
+    formatNumber: (style, value, options) => formatNumber(bundle, current, style, value, options),
+    numberOptions: (namespace, options) => numberOptions(bundle, current, namespace, options),
+    pluralize: (count, singular, plural) => pluralizeWord(bundle, current, count, singular, plural),
+    exists: (key, options = {}) => resolve(bundle, current, key, { lazy, ...options }).found,
+    /** The raw value of a key through the run-time chain (a hash, an array, a string), or undefined. */
+    lookup: (key, options = {}) => {
+      const r = resolve(bundle, current, key, { lazy, ...options });
+      return r.found ? r.value : undefined;
+    },
+    /** The raw value of a key through the locale and its declared fallbacks only. */
+    lookupDeclared: (key) => firstIn(bundle, declaredChain(bundle, current), key)?.value,
+    withLocale: (other) => createI18n({ bundle, locale: other, reporter, lazy }),
+    withLazy: (scope) => createI18n({ bundle, locale: current, reporter, lazy: scope }),
+  };
+  return self;
+}

package/src/i18n/missing.js

@@ -0,0 +1,35 @@
+// The site's run-time missing-key report (spec S4 § Run time; ADR-223 D10): a key composed at run time
+// that is still unresolved after its chain is rendered humanized, and reported to the product host at
+// `POST /_air/i18n-missing` as `{release, locale, key}` — at most once per key per page load (the
+// lifetime of one reporter), and at most MAX_KEYS_PER_PAGE_LOAD keys, so a page composing keys from
+// unbounded data cannot turn into a report per render.
+
+export const MISSING_REPORT_PATH = '/_air/i18n-missing';
+export const MAX_KEYS_PER_PAGE_LOAD = 100;
+
+/**
+ * @param {{release: string, locale: string, send?: (path: string, body: string) => void}} init
+ *   `send` defaults to navigator.sendBeacon (a report never delays or fails the page).
+ * @returns {(key: string) => void}
+ */
+export function createMissingReporter({ release, locale, send }) {
+  const seen = new Set();
+  const transport =
+    send ??
+    ((path, body) => {
+      if (typeof navigator !== 'undefined' && typeof navigator.sendBeacon === 'function') {
+        navigator.sendBeacon(path, new Blob([body], { type: 'application/json' }));
+      } else if (typeof fetch === 'function') {
+        fetch(path, { method: 'POST', headers: { 'content-type': 'application/json' }, body, keepalive: true }).catch(() => {});
+      }
+    });
+  return (key) => {
+    if (seen.has(key) || seen.size >= MAX_KEYS_PER_PAGE_LOAD) return;
+    seen.add(key);
+    try {
+      transport(MISSING_REPORT_PATH, JSON.stringify({ release, locale, key }));
+    } catch {
+      // a report is best-effort: the rendering already degraded, the page must not
+    }
+  };
+}

package/src/i18n/negotiate.js

@@ -0,0 +1,67 @@
+// Locale negotiation (ADR-223 D7; spec S4 § Locale negotiation). The site's order:
+//   1. the `locale` query parameter, when it names an available locale;
+//   2. reserved for the end-user and organisation preference (#632) — the `preferred` hook;
+//   3. navigator.languages (what the browser also sends as Accept-Language), RFC 4647 lookup;
+//   4. default_locale.
+// Nothing stores the choice outside the URL.
+
+/** The `locale` query parameter of a URL (a string, URL or URLSearchParams). */
+export function localeFromUrl(url) {
+  if (url === undefined || url === null) return undefined;
+  const params = url instanceof URLSearchParams ? url : new URL(String(url), 'http://x').searchParams;
+  return params.get('locale') ?? undefined;
+}
+
+function canonical(available, tag) {
+  const t = String(tag).toLowerCase();
+  return available.find((a) => a.toLowerCase() === t);
+}
+
+/**
+ * RFC 4647 § 3.4 Lookup: for each language range in priority order, the range and then each
+ * truncation of it (dropping the last subtag, and a single-character subtag with it) is compared
+ * case-insensitively with the available tags; the first hit wins. `*` never matches.
+ */
+export function lookupLocale(ranges, available) {
+  for (const range of ranges ?? []) {
+    if (!range || range === '*') continue;
+    const subtags = String(range).split('-');
+    while (subtags.length > 0) {
+      const hit = canonical(available, subtags.join('-'));
+      if (hit) return hit;
+      subtags.pop();
+      if (subtags.length > 0 && subtags[subtags.length - 1].length === 1) subtags.pop();
+    }
+  }
+  return undefined;
+}
+
+/** The language ranges of an Accept-Language header, by descending q (ties keep header order). */
+export function acceptLanguage(header) {
+  if (!header) return [];
+  return String(header)
+    .split(',')
+    .map((part, index) => {
+      const [range, ...params] = part.trim().split(';');
+      const q = params.map((p) => p.trim()).find((p) => p.startsWith('q='));
+      return { range: range.trim(), q: q ? Number(q.slice(2)) : 1, index };
+    })
+    .filter((r) => r.range && Number.isFinite(r.q) && r.q > 0)
+    .sort((a, b) => b.q - a.q || a.index - b.index)
+    .map((r) => r.range);
+}
+
+/**
+ * The site's locale for a page load.
+ * @param {{url?: string|URL|URLSearchParams, languages?: readonly string[], available: string[],
+ *          defaultLocale: string, preferred?: () => (string|undefined)}} input
+ */
+export function negotiateLocale({ url, languages, available, defaultLocale, preferred }) {
+  const param = localeFromUrl(url);
+  const fromParam = param && canonical(available, param);
+  if (fromParam) return fromParam;
+  const pref = preferred?.();
+  const fromPref = pref && canonical(available, pref);
+  if (fromPref) return fromPref;
+  return lookupLocale(languages, available) ?? defaultLocale;
+}

package/src/i18n/plural.js

@@ -0,0 +1,41 @@
+// CLDR plural categories (UTS #35 Part 3) evaluated over the bundle's rule AST — never Intl.PluralRules.
+import { parseDecimal } from './decimal.js';
+
+/** The UTS #35 operands of a count (a number or a decimal string; visible fraction digits count). */
+export function operands(count) {
+  const d = parseDecimal(count);
+  const frac = d.frac;
+  const trimmed = frac.replace(/0+$/, '');
+  const i = Number(d.int);
+  return {
+    n: Number(`${d.int}${frac ? '.' + frac : ''}`),
+    i,
+    v: frac.length,
+    w: trimmed.length,
+    f: frac ? Number(frac) : 0,
+    t: trimmed ? Number(trimmed) : 0,
+    e: 0,
+  };
+}
+
+function relationMatches(rel, ops) {
+  let value = ops[rel.operand];
+  if (rel.mod) value = rel.operand === 'n' ? value % rel.mod : value % rel.mod;
+  // n (and n % m) matches a range only when integral (UTS #35: ranges are integer ranges).
+  const integral = rel.operand !== 'n' || (ops.t === 0 && Number.isInteger(value));
+  const inRange = integral && rel.ranges.some(([lo, hi]) => value >= lo && value <= hi);
+  return rel.negated ? !inRange : inRange;
+}
+
+function ruleMatches(rule, ops) {
+  return rule.or.some((and) => and.every((rel) => relationMatches(rel, ops)));
+}
+
+/** The CLDR category of `count` under a locale's ordered categories (the last is `other`). */
+export function pluralCategory(categories, count) {
+  const ops = operands(count);
+  for (const { category, rule } of categories) {
+    if (category !== 'other' && ruleMatches(rule, ops)) return category;
+  }
+  return 'other';
+}

package/src/i18n/strftime.js

@@ -0,0 +1,76 @@
+// The strftime subset of spec S4 § Constants, as Rails' I18n `l` renders it: the name directives
+// (%a %A %b %B %p %P) come from the locale data, everything else is Ruby's strftime.
+import { dayOfYear } from './civil.js';
+
+const pad = (n, w, c = '0') => String(n).padStart(w, c);
+
+/**
+ * Format a broken-down local time.
+ * @param {string} format
+ * @param {{year,month,day,hour,minute,second,wday,offset:number|null,abbr:string|null}} t
+ *   offset/abbr null for a civil date (Ruby Date renders %Z as +00:00 and %z as +0000).
+ * @param {(kind: 'day_names'|'abbr_day_names'|'month_names'|'abbr_month_names'|'am'|'pm') => any} names
+ */
+export function strftime(format, t, names) {
+  let out = '';
+  for (let i = 0; i < format.length; i += 1) {
+    const c = format[i];
+    if (c !== '%' || i === format.length - 1) {
+      out += c;
+      continue;
+    }
+    let spec = format[i + 1];
+    let flag = '';
+    if (spec === '-' && i + 2 < format.length) {
+      flag = '-';
+      spec = format[i + 2];
+    }
+    const r = directive(flag, spec, t, names);
+    if (r === null) {
+      out += c; // an unsupported directive is emitted as written (Ruby)
+      continue;
+    }
+    out += r;
+    i += flag ? 2 : 1;
+  }
+  return out;
+}
+
+function directive(flag, spec, t, names) {
+  const hour12 = t.hour % 12 === 0 ? 12 : t.hour % 12;
+  if (flag === '-') {
+    switch (spec) {
+      case 'm': return String(t.month);
+      case 'd': return String(t.day);
+      case 'H': return String(t.hour);
+      case 'I': return String(hour12);
+      default: return null;
+    }
+  }
+  switch (spec) {
+    case 'Y': return String(t.year);
+    case 'y': return pad(((t.year % 100) + 100) % 100, 2);
+    case 'm': return pad(t.month, 2);
+    case 'd': return pad(t.day, 2);
+    case 'e': return pad(t.day, 2, ' ');
+    case 'H': return pad(t.hour, 2);
+    case 'I': return pad(hour12, 2);
+    case 'M': return pad(t.minute, 2);
+    case 'S': return pad(t.second, 2);
+    case 'j': return pad(dayOfYear(t.year, t.month, t.day), 3);
+    case 'p': return String(names(t.hour < 12 ? 'am' : 'pm')).toUpperCase();
+    case 'P': return String(names(t.hour < 12 ? 'am' : 'pm')).toLowerCase();
+    case 'A': return names('day_names')[t.wday];
+    case 'a': return names('abbr_day_names')[t.wday];
+    case 'B': return names('month_names')[t.month];
+    case 'b': return names('abbr_month_names')[t.month];
+    case 'Z': return t.offset === null ? '+00:00' : t.abbr;
+    case 'z': {
+      const o = t.offset ?? 0;
+      const a = Math.abs(o);
+      return `${o < 0 ? '-' : '+'}${pad(Math.floor(a / 3600), 2)}${pad(Math.floor((a % 3600) / 60), 2)}`;
+    }
+    case '%': return '%';
+    default: return null;
+  }
+}

package/src/i18n/zone.js

@@ -0,0 +1,39 @@
+// Time-zone rendering from the bundle's zone rules (RFC 8536's model; contracts/deploy/v1/
+// locale-bundle-v1.json `zone`) — never the host's time-zone database.
+import { civilFromDays, daysFromCivil, floorDiv } from './civil.js';
+
+/** The local time type ({offset, dst, abbr}) of `zone` at Unix second `at`. */
+export function zoneAt(zone, at) {
+  const ts = zone.transitions;
+  if (ts.length === 0) return zone.rule ? ruleAt(zone.rule, at) : zone.initial;
+  if (at < ts[0].at) return zone.initial;
+  let lo = 0;
+  let hi = ts.length - 1;
+  while (lo < hi) {
+    const mid = (lo + hi + 1) >> 1;
+    if (ts[mid].at <= at) lo = mid;
+    else hi = mid - 1;
+  }
+  if (lo === ts.length - 1 && zone.rule) return ruleAt(zone.rule, at);
+  const { offset, dst, abbr } = ts[lo];
+  return { offset, dst, abbr };
+}
+
+function ruleAt(rule, at) {
+  if (!rule.dst) return rule.std;
+  const [year] = civilFromDays(floorDiv(at + rule.std.offset, 86400));
+  const start = wallSecond(year, rule.start) - rule.std.offset;
+  const end = wallSecond(year, rule.end) - rule.dst.offset;
+  const inDst = start < end ? at >= start && at < end : !(at >= end && at < start);
+  return inDst ? rule.dst : rule.std;
+}
+
+// The local wall-clock second (seconds since the epoch, as if local time were UTC) of an Mm.w.d date.
+function wallSecond(year, d) {
+  const first = daysFromCivil(year, d.month, 1);
+  const weekday = (((first % 7) + 7 + 4) % 7); // 1970-01-01 was a Thursday
+  let day = first + ((d.weekday - weekday + 7) % 7) + (d.week - 1) * 7;
+  const next = d.month === 12 ? daysFromCivil(year + 1, 1, 1) : daysFromCivil(year, d.month + 1, 1);
+  while (day >= next) day -= 7;
+  return day * 86400 + d.time;
+}

package/src/index.js

@@ -0,0 +1,16 @@
+// @aircloudhq/web — the framework-neutral core (ADR-222 D3). Each module is also its own entry point
+// (`@aircloudhq/web/helpers/number`, …); the React bindings are `@aircloudhq/web/react`.
+export * from './helpers/number.js';
+export * from './helpers/date.js';
+export * from './helpers/text.js';
+export * from './helpers/translation.js';
+export * from './helpers/url.js';
+export * from './helpers/navigation.js';
+export * from './helpers/sanitize.js';
+export * from './helpers/tag.js';
+export * from './helpers/form.js';
+export * from './model.js';
+export * from './resource.js';
+export * from './api.js';
+export { createI18n, negotiateLocale, createMissingReporter } from './i18n/index.js';
+export { setCurrentI18n, currentI18n } from './i18n/current.js';