@wix/himalaya-cli 0.1614.0 → 0.1616.0

package/templates/salon-spa/tier5-src/_shared/engine-intl.ts

@@ -0,0 +1,508 @@
+// ECMA-402 is NOT part of the Tier-5 floor. Measured across the engines we actually ship
+// (engine-parity runners, #1367):
+//
+//   engine                          typeof Intl
+//   V8      (web, Android WebView)  object
+//   JSC     (iOS, macOS)            object
+//   QuickJS-ng (watchOS, Wear OS)   **undefined**
+//
+// The wrist engine has no ECMA-402 at all — `grep -c Intl quickjs.c` → 0, and its maintainer
+// ruled ICU out as too large (quickjs-ng#467). RFC 0051's per-surface projection does NOT subset
+// destinations: a watch keeps every screen the phone has and only REMAPS which one an entry
+// opens. So any screen in a watch/Wear-enabled app can execute on QuickJS, and a bare `Intl.*`
+// there is a `ReferenceError`.
+//
+// That is not hypothetical. `himi-branded-lite-order.formatDate` called `new Intl.DateTimeFormat`
+// unguarded and with no try/catch, which KILLS the screen on the wrist rather than degrading it.
+// `himi-events-detail` had the softer version — a guarded `Intl.NumberFormat` whose catch left a
+// ticket price rendering "25" where the phone shows "$25", i.e. a price that reads as a quantity.
+//
+// These helpers are the sanctioned way to format across the whole fleet: real ECMA-402 where it
+// exists, a deterministic en-US-shaped fallback where it does not, and never a throw.
+
+import { appLocale } from "./app-locale.js";
+
+/** Is ECMA-402 actually present in THIS engine? Cheap, and safe in a realm without `Intl`. */
+export function hasIntl(): boolean {
+  return typeof Intl !== "undefined";
+}
+
+const MONTHS_SHORT = [
+  "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
+] as const;
+
+function pad2(n: number): string {
+  return n < 10 ? `0${n}` : `${n}`;
+}
+
+/** `h:mm AM/PM`, matching what `timeStyle: "short"` renders for en-US. */
+function clock12(d: Date): string {
+  const h = d.getHours();
+  const suffix = h < 12 ? "AM" : "PM";
+  const hour = h % 12 === 0 ? 12 : h % 12;
+  return `${hour}:${pad2(d.getMinutes())} ${suffix}`;
+}
+
+const WEEKDAYS_SHORT = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"] as const;
+
+const MONTHS_LONG = [
+  "January", "February", "March", "April", "May", "June",
+  "July", "August", "September", "October", "November", "December",
+] as const;
+
+/**
+ * A DateTimeFormat for `timeZone` when one is given and this engine knows it. An unknown or
+ * malformed IANA id is a RangeError in ECMA-402; these helpers never throw, so it degrades to
+ * the device zone rather than killing the screen. Without Intl there is no zone database at all,
+ * and the fallbacks below render in the device zone for the same reason.
+ *
+ * Formatters are memoised per (locale, zone, options): a management page formats several dates
+ * per row, and building a DateTimeFormat (or throwing on a bad zone) each time is not free on
+ * JSC or QuickJS. Only call it where `hasIntl()` holds — every caller does.
+ */
+const FORMATTERS = new Map<string, Intl.DateTimeFormat>();
+function dateFormat(locale: string, options: Intl.DateTimeFormatOptions, timeZone?: string): Intl.DateTimeFormat {
+  const key = `${locale}|${timeZone ?? ""}|${JSON.stringify(options)}`;
+  let formatter = FORMATTERS.get(key);
+  if (!formatter) {
+    if (hasIntl()) {
+      if (timeZone) {
+        try {
+          formatter = new Intl.DateTimeFormat(locale, { ...options, timeZone });
+        } catch {
+          /* unknown zone: device zone below, remembered under this key */
+        }
+      }
+      formatter ??= new Intl.DateTimeFormat(locale, options);
+      FORMATTERS.set(key, formatter);
+    }
+  }
+  return formatter as Intl.DateTimeFormat;
+}
+
+// The four shapes below are not invented — they are the option bags this corpus actually uses,
+// counted across every bundle: "Jan 5, 2026" (33 sites), "Jan 5" (11), "Mon, Jan 5, 3:07 PM" (8)
+// and "Jan 5, 3:07 PM" (4). Naming them means a conversion is a one-line swap rather than a
+// judgement call about which fallback is close enough, and every one is diffed against real
+// ECMA-402 in engine-intl-fallback.test.ts.
+
+/** `{ month: "short", day: "numeric", year: "numeric" }` — "Jan 5, 2026". */
+export function formatDateMedium(date: Date, locale = "en-US", timeZone?: string): string {
+  if (hasIntl()) {
+    return dateFormat(locale, { month: "short", day: "numeric", year: "numeric" }, timeZone).format(date);
+  }
+  return `${MONTHS_SHORT[date.getMonth()]} ${date.getDate()}, ${date.getFullYear()}`;
+}
+
+/** `{ month: "short", day: "numeric" }` — "Jan 5". */
+export function formatMonthDay(date: Date, locale = "en-US", timeZone?: string): string {
+  if (hasIntl()) {
+    return dateFormat(locale, { month: "short", day: "numeric" }, timeZone).format(date);
+  }
+  return `${MONTHS_SHORT[date.getMonth()]} ${date.getDate()}`;
+}
+
+/** `{ month: "long", day: "numeric" }` — "January 5". */
+export function formatMonthDayLong(date: Date, locale = "en-US", timeZone?: string): string {
+  if (hasIntl()) {
+    return dateFormat(locale, { month: "long", day: "numeric" }, timeZone).format(date);
+  }
+  return `${MONTHS_LONG[date.getMonth()]} ${date.getDate()}`;
+}
+
+const WEEKDAYS_LONG = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"] as const;
+
+/** `{ weekday: "short", month: "short", day: "numeric" }` — "Mon, Jan 5". */
+export function formatWeekdayMonthDay(date: Date, locale = "en-US", timeZone?: string): string {
+  if (hasIntl()) {
+    return dateFormat(locale, { weekday: "short", month: "short", day: "numeric" }, timeZone).format(date);
+  }
+  return `${WEEKDAYS_SHORT[date.getDay()]}, ${MONTHS_SHORT[date.getMonth()]} ${date.getDate()}`;
+}
+
+/** `{ weekday: "long", month: "long", day: "numeric" }` — "Monday, January 5". */
+export function formatWeekdayMonthDayLong(date: Date, locale = "en-US", timeZone?: string): string {
+  if (hasIntl()) {
+    return dateFormat(locale, { weekday: "long", month: "long", day: "numeric" }, timeZone).format(date);
+  }
+  return `${WEEKDAYS_LONG[date.getDay()]}, ${MONTHS_LONG[date.getMonth()]} ${date.getDate()}`;
+}
+
+/** `{ weekday: "short", month: "short", day: "numeric", hour: "numeric", minute: "2-digit" }`
+ *  — "Mon, Jan 5, 3:07 PM". */
+export function formatWeekdayDateTime(date: Date, locale = "en-US", timeZone?: string): string {
+  if (hasIntl()) {
+    return dateFormat(locale, {
+      weekday: "short", month: "short", day: "numeric", hour: "numeric", minute: "2-digit",
+    }, timeZone).format(date);
+  }
+  return `${WEEKDAYS_SHORT[date.getDay()]}, ${MONTHS_SHORT[date.getMonth()]} ${date.getDate()}, ${clock12(date)}`;
+}
+
+/** `{ month: "short", day: "numeric", hour: "numeric", minute: "2-digit" }` — "Jan 5, 3:07 PM". */
+export function formatMonthDayTime(date: Date, locale = "en-US", timeZone?: string): string {
+  if (hasIntl()) {
+    return dateFormat(locale, {
+      month: "short", day: "numeric", hour: "numeric", minute: "2-digit",
+    }, timeZone).format(date);
+  }
+  return `${MONTHS_SHORT[date.getMonth()]} ${date.getDate()}, ${clock12(date)}`;
+}
+
+/**
+ * `dateStyle: "medium", timeStyle: "short"` — "Jan 5, 2026, 3:07 PM".
+ * Falls back to the same SHAPE (not a different one) so a screen does not visibly change
+ * character between a phone and a watch.
+ */
+export function formatDateTimeMedium(date: Date, locale = "en"): string {
+  if (hasIntl()) {
+    return new Intl.DateTimeFormat(locale, { dateStyle: "medium", timeStyle: "short" }).format(date);
+  }
+  return `${MONTHS_SHORT[date.getMonth()]} ${date.getDate()}, ${date.getFullYear()}, ${clock12(date)}`;
+}
+
+/**
+ * Currency, e.g. "$25.00". The fallback covers the symbol-prefix currencies these apps actually
+ * use and degrades to "CODE amount" for anything else — deliberately NOT a bare number, because
+ * that is the exact defect this exists to prevent (a price rendering as a quantity).
+ */
+const CURRENCY_SYMBOL: Record<string, string> = {
+  USD: "$", EUR: "€", GBP: "£", ILS: "₪", JPY: "¥", CAD: "CA$", AUD: "A$",
+};
+
+/**
+ * ISO 4217 minor units, for the currencies that are NOT the default 2.
+ *
+ * Without this the fallback rendered every non-JPY currency with 2 decimals while Intl used the
+ * currency's natural precision — so a Bahraini price was "BHD 25.00" on the wrist and
+ * "BHD 25.000" on the phone. Formatting money differently per engine is the exact defect this
+ * helper exists to prevent, so the table is part of the contract, not a nicety.
+ */
+const CURRENCY_DIGITS: Record<string, number> = {
+  // Zero-decimal
+  BIF: 0, CLP: 0, DJF: 0, GNF: 0, ISK: 0, JPY: 0, KMF: 0, KRW: 0, PYG: 0, RWF: 0,
+  UGX: 0, UYI: 0, VND: 0, VUV: 0, XAF: 0, XOF: 0, XPF: 0,
+  // Three-decimal
+  BHD: 3, IQD: 3, JOD: 3, KWD: 3, LYD: 3, OMR: 3, TND: 3,
+  // Four-decimal
+  CLF: 4, UYW: 4,
+};
+
+export function formatCurrency(
+  amount: number,
+  currency = "USD",
+  locale = appLocale(),
+  /** Omit for the currency's natural digits. Pass 0 to render a whole amount as "$25" rather
+   *  than "$25.00" — Intl clamps the minimum down to match, so max<min does not throw here. */
+  maximumFractionDigits?: number,
+): string {
+  if (!Number.isFinite(amount)) return "";
+  if (hasIntl()) {
+    // The Intl branch CAN throw: `new Intl.NumberFormat(…, { currency })` raises a RangeError for
+    // any code that is not three letters ("US", "12", ""), and a currency arriving from payload
+    // data is exactly where that happens. This helper replaced call sites that had their own
+    // try/catch (himi-events-detail's tierPrice returned the raw amount), so without this the
+    // refactor would have REMOVED a safety net and turned a degraded price into a dead service on
+    // web, iOS and Android alike — worse than the wrist bug it was written to fix.
+    //
+    // Falling through to the fallback rather than rethrowing also degrades better than the code
+    // it replaced: that returned a bare number, this still carries the currency code.
+    try {
+      return new Intl.NumberFormat(locale, {
+        style: "currency",
+        currency,
+        ...(maximumFractionDigits != null ? { maximumFractionDigits } : {}),
+      }).format(amount);
+    } catch { /* malformed currency — use the engine-independent path below */ }
+  }
+  // A blank/whitespace currency would otherwise produce " 25.00" — a bare number, which is the
+  // very defect this helper exists to prevent. Fall back to the documented default rather than
+  // emitting an unlabelled amount. (Found by the "never a bare number" assertion, not by reading.)
+  const code = (currency || "").trim().toUpperCase() || "USD";
+  const symbol = CURRENCY_SYMBOL[code];
+  // The sign goes OUTSIDE the symbol: ECMA-402 renders -42.5 USD as "-$42.50", not "$-42.50".
+  // Caught by diffing this fallback against Intl rather than by reading it.
+  const sign = amount < 0 ? "-" : "";
+  const abs = Math.abs(amount);
+  const digits = maximumFractionDigits ?? CURRENCY_DIGITS[code] ?? 2;
+  const raw = abs.toFixed(digits);
+  // Same trap as formatNumber: `toFixed` goes EXPONENTIAL at >=1e21, and groupThousands would
+  // then comma up the exponent ("1e,+21"). No real price is that large, but emitting garbage is
+  // never the right answer to an unexpected input.
+  const fixed = raw.includes("e") || raw.includes("E") ? String(abs) : groupThousands(raw);
+  return symbol ? `${sign}${symbol}${fixed}` : `${sign}${code} ${fixed}`;
+}
+
+/** "1234567.89" → "1,234,567.89". `toLocaleString` cannot be used: on QuickJS it silently
+ *  returns the UNGROUPED string rather than throwing, which is why the wrist showed "1234.5"
+ *  where every other engine showed "1,234.5". */
+function groupThousands(fixed: string): string {
+  const [whole, frac] = fixed.split(".");
+  const sign = whole.startsWith("-") ? "-" : "";
+  const digits = sign ? whole.slice(1) : whole;
+  let out = "";
+  for (let i = 0; i < digits.length; i++) {
+    if (i > 0 && (digits.length - i) % 3 === 0) out += ",";
+    out += digits[i];
+  }
+  return frac ? `${sign}${out}.${frac}` : `${sign}${out}`;
+}
+
+/**
+ * Plain grouped number, e.g. "1,234.5".
+ *
+ * Two things the first cut of this got wrong, both found by diffing against Intl over values
+ * chosen to be AWKWARD rather than tidy:
+ *
+ *   • `Intl.NumberFormat` defaults to `maximumFractionDigits: 3`. Feeding it `2/3` gives
+ *     "0.667"; a fallback built on `String(value)` gave "0.6666666666666666".
+ *   • `String(value)` is EXPONENTIAL outside ~1e21 / 1e-7, and the grouping loop below happily
+ *     inserted commas into the exponent — `1e21` came out as "1e,+21" and `1e-7` as "1,e-7".
+ *     Garbage, and silently so, because nothing in the corpus's tidy test numbers reached it.
+ */
+export function formatNumber(value: number, locale = appLocale()): string {
+  if (!Number.isFinite(value)) return "";
+  if (hasIntl()) return new Intl.NumberFormat(locale).format(value);
+  // `toFixed` itself returns exponential notation at >=1e21, so anything that big keeps the
+  // plain JS form rather than being mangled. Intl would expand it in full; a number that large
+  // is not a price or a count, and an honest "1e+21" beats a wrong "1e,+21".
+  const fixed = value.toFixed(3);
+  if (fixed.includes("e") || fixed.includes("E")) return String(value);
+  // Trailing zeros go, so an integer stays "1,000" instead of "1,000.000".
+  const trimmed = fixed.includes(".") ? fixed.replace(/0+$/, "").replace(/\.$/, "") : fixed;
+  return groupThousands(trimmed);
+}
+
+/** Strip combining marks so "Ändern" folds to "andern". `String.prototype.normalize` is
+ *  ECMA-262, NOT ECMA-402 — which is exactly why it is usable here: it exists on the engine that
+ *  has no `Intl`. The range is the Unicode combining-diacritical block, written as an explicit
+ *  range rather than a `\p{M}` property escape so no engine needs RegExp property support. */
+function foldDiacritics(s: string): string {
+  try {
+    return s.normalize("NFD").replace(/[̀-ͯ]/g, "");
+  } catch {
+    return s; // no normalize (should not happen) — degrade to the un-folded form
+  }
+}
+
+/**
+ * Locale-aware string ordering for SORTS.
+ *
+ * `localeCompare` is the trap here, because it does not throw where ECMA-402 is missing — it
+ * silently falls back to codepoint order. Measured on the engines we ship, that is not a subtle
+ * difference: for a realistic product list the wrist produced
+ *
+ *   Banana, Zoë, andern, apple, cherry, Ändern, Über, éclair      ← raw codepoint (QuickJS-ng)
+ *   andern, Ändern, apple, Banana, cherry, éclair, Über, Zoë      ← ICU (V8/JSC)
+ *
+ * i.e. a list that looks shuffled rather than sorted, with no error anywhere to explain it.
+ *
+ * The phone path is UNCHANGED — it is still `Intl.Collator`, so nothing about existing ordering
+ * moves. Only the engine that lacked ECMA-402 changes, and it changes from codepoint order to a
+ * case-folded, diacritic-folded comparison that agreed with ICU on 576/576 pairs of the probe
+ * corpus (accents included). This is deliberately NOT "pick one algorithm for every engine":
+ * that framing would have traded a wrist bug for a phone regression, and it is unnecessary.
+ */
+export function compareText(a: string, b: string, locale = "en"): number {
+  if (hasIntl()) return new Intl.Collator(locale).compare(a, b);
+  const fa = foldDiacritics(a.toLowerCase());
+  const fb = foldDiacritics(b.toLowerCase());
+  if (fa < fb) return -1;
+  if (fa > fb) return 1;
+  // Same letters ignoring case and accents — fall back through the finer distinctions so the
+  // order is TOTAL (a comparator that returns 0 for distinct strings makes a sort unstable).
+  const ca = a.toLowerCase(), cb = b.toLowerCase();
+  if (ca < cb) return -1;
+  if (ca > cb) return 1;
+  if (a === b) return 0;
+  // en-US collation puts lowercase before uppercase for the same letter, which is the OPPOSITE
+  // of codepoint order — hence the inversion rather than a plain comparison.
+  return a > b ? -1 : 1;
+}
+
+/**
+ * Ordering for machine timestamps (ISO-8601, RFC-3339) and other fixed-format ASCII keys.
+ *
+ * Exists to keep `localeCompare` away from them. Sorting `"2026-01-05T15:07:00Z"` through a
+ * COLLATOR is the wrong tool — collation carries locale rules a timestamp has no use for, and on
+ * an engine without ECMA-402 it silently becomes codepoint order anyway. Measured: for ISO
+ * strings, plain comparison and `localeCompare` agree on 36/36 pairs, so this is a no-op on
+ * every engine AND removes the engine-variance question entirely.
+ */
+export function compareIso(a: string, b: string): number {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+const MONTH_INDEX: Record<string, number> = {
+  jan: 0, feb: 1, mar: 2, apr: 3, may: 4, jun: 5,
+  jul: 6, aug: 7, sep: 8, oct: 9, nov: 10, dec: 11,
+};
+
+/**
+ * Epoch-ms for a date string that may be ISO-8601 **or** RFC-822/2822 ("Sun, 02 Aug 2026"), the
+ * shape RSS feeds use. `NaN` when it is neither.
+ *
+ * Hand-parsed rather than handed to `Date.parse` because `Date.parse` is only SPECIFIED for the
+ * ISO format — everything else is implementation-defined, which is precisely the kind of
+ * per-engine variance this module exists to remove.
+ */
+export function parseDateish(value: string): number {
+  if (!value) return NaN;
+  // ISO / RFC-3339 — `Date` parses this by spec on every engine.
+  if (/^\d{4}-\d{2}-\d{2}/.test(value)) return new Date(value).getTime();
+  // RFC-822/2822: "[Ddd, ]DD Mon YYYY[ HH:MM[:SS]]"
+  const m = value.match(/(\d{1,2})\s+([A-Za-z]{3})[a-z]*\s+(\d{4})(?:\s+(\d{2}):(\d{2})(?::(\d{2}))?)?/);
+  if (!m) return NaN;
+  const month = MONTH_INDEX[m[2].toLowerCase()];
+  if (month === undefined) return NaN;
+  return Date.UTC(Number(m[3]), month, Number(m[1]), Number(m[4] ?? 0), Number(m[5] ?? 0), Number(m[6] ?? 0));
+}
+
+/**
+ * Chronological ordering for date strings — ASCENDING (oldest first); negate for newest-first.
+ *
+ * This exists because comparing RFC-822 dates as STRINGS sorts by weekday name. Measured on the
+ * podcast corpus, a "latest episodes" list built that way rendered
+ *
+ *   Wed, 01 Jan 2025   ← shown FIRST
+ *   Tue, 21 Jul 2026
+ *   …
+ *   Fri, 15 Aug 2026   ← the newest episode, shown LAST
+ *
+ * and it was wrong on EVERY engine, not just the one missing ECMA-402 — a plain product bug that
+ * the engine work happened to surface. Unparseable values sort last rather than throwing, so one
+ * malformed feed entry cannot take the screen down.
+ */
+export function compareDate(a: string, b: string): number {
+  const ta = parseDateish(a);
+  const tb = parseDateish(b);
+  const aBad = Number.isNaN(ta);
+  const bBad = Number.isNaN(tb);
+  if (aBad && bBad) return compareIso(a, b); // both unparseable — arbitrary but TOTAL
+  if (aBad) return 1;
+  if (bBad) return -1;
+  return ta - tb;
+}
+
+/**
+ * Newest-first, which is what every call site here actually wants.
+ *
+ * A separate function rather than asking callers to write `-compareDate(a, b)`, because negating
+ * also flips the unparseable-values-last rule to unparseable-values-FIRST — a malformed feed entry
+ * would head the "latest episodes" list. My own test caught that on the negation idiom, which is
+ * exactly the footgun worth deleting rather than documenting.
+ */
+export function compareDateDesc(a: string, b: string): number {
+  const ta = parseDateish(a);
+  const tb = parseDateish(b);
+  const aBad = Number.isNaN(ta);
+  const bBad = Number.isNaN(tb);
+  if (aBad && bBad) return compareIso(a, b);
+  if (aBad) return 1; // unparseable stays LAST in this direction too
+  if (bBad) return -1;
+  return tb - ta;
+}
+
+// --- [branded-lite-qa] #3079: one pattern per fact ---------------------------------------
+//
+// Before these existed, four screens formatted the same money four ways — Shop "69.00 ₪" (Wix's
+// pre-formatted string), Services "₪70" (0 decimals), Menu "₪32.00", Plans "$24" — and two
+// screens formatted the same clock two ways (Events "9:00 PM-11:00 PM", Reserve "20:00").
+// Customers read that as sloppiness, and a whole "₪70" beside "₪69.50" reads as a different
+// kind of number. So: one money pattern, one clock, one range.
+
+// Money uses `formatCurrency(amount, currency)` — English unless the app pins another language, see app-locale — the currency's NATURAL decimals
+// ("₪70.00", "¥500") — for Shop, Menu and every other price. The one exception is a Bookings
+// SERVICE price (`_shared/wix-service-price.ts`): it drops the cents of a whole amount ("₪70",
+// "₪69.50"), the format the redesigned service screen and services list were approved with. It
+// must read the same on every screen that shows a service (the list, the service screen, the
+// time screen, Home, the agenda); do not put those back on natural decimals one screen at a time.
+
+const KNOWN_SYMBOLS = new Set(Object.values(CURRENCY_SYMBOL));
+
+/** Wix hands some prices over PRE-formatted in the site's regional style — "69.00 ₪" with the
+ *  symbol trailing, often wrapped in bidi marks. Reorder those to the house pattern ("₪69.00") so
+ *  they match every price we format ourselves. Only an en-shaped number ("69.00", "1,234.50") with
+ *  a known trailing symbol is reordered: a comma-decimal or space-grouped string ("69,00 €",
+ *  "1 234,56 €") is kept as Wix wrote it, because half-converting it would be worse. Anything else
+ *  ("Market price") is returned trimmed. The store SDK's product price applies the same rule. */
+export function normalizeFormattedPrice(formatted: string): string {
+  const raw = (formatted || "").replace(/[‎‏]/g, "").trim();
+  const m = /^(-?)(\d{1,3}(?:,\d{3})*(?:\.\d+)?|\d+(?:\.\d+)?)[\s  ]*(\S+)$/.exec(raw);
+  if (!m || !KNOWN_SYMBOLS.has(m[3])) return raw;
+  return `${m[1]}${m[3]}${m[2]}`;
+}
+
+function clockParts(d: Date, locale: string, timeZone?: string): { time: string; meridiem: string } {
+  const full = hasIntl()
+    ? dateFormat(locale, { hour: "numeric", minute: "2-digit", hour12: true }, timeZone).format(d)
+    : clock12(d);
+  // ICU puts a narrow no-break space before the meridiem; normalize so callers can split on it.
+  const clean = full.replace(/[  ]/g, " ");
+  const m = /^(.*?)\s*([AP]\.?M\.?)$/i.exec(clean);
+  return m ? { time: m[1], meridiem: m[2] } : { time: clean, meridiem: "" };
+}
+
+/** "8:00 PM" — the one clock every customer screen uses (12-hour, en-US shape). */
+export function formatClock(date: Date, locale = "en-US", timeZone?: string): string {
+  const { time, meridiem } = clockParts(date, locale, timeZone);
+  return meridiem ? `${time} ${meridiem}` : time;
+}
+
+/** Is this ISO instant before `now`? A missing or unparseable value is NOT past — "no expiry"
+ *  must never classify an offer as expired. */
+export function isPastDate(iso: string | undefined | null, now: number = Date.now()): boolean {
+  if (!iso) return false;
+  const t = Date.parse(iso);
+  return !Number.isNaN(t) && t < now;
+}
+
+/** The calendar day `date` falls on in `timeZone` (device zone when absent, unknown, or when
+ *  the engine has no Intl), as `YYYY-MM-DD`. For "is this today / this year" comparisons. */
+export function calendarDay(date: Date, timeZone?: string): string {
+  if (hasIntl()) {
+    const parts = dateFormat("en-CA", { year: "numeric", month: "2-digit", day: "2-digit" }, timeZone).formatToParts(date);
+    const get = (type: string) => parts.find((p) => p.type === type)?.value ?? "";
+    return `${get("year")}-${get("month")}-${get("day")}`;
+  }
+  return `${date.getFullYear()}-${pad2(date.getMonth() + 1)}-${pad2(date.getDate())}`;
+}
+
+/**
+ * [timeZone]'s offset from UTC in ms at instant [at] (Asia/Jerusalem in winter: 7_200_000), or NaN
+ * where it cannot be known — no ECMA-402 (the wrist engines) or a zone this engine does not know.
+ * Callers fall back to the device zone on NaN, as the formatters above do.
+ */
+export function zoneOffsetAt(at: number, timeZone: string): number {
+  if (hasIntl() && Number.isFinite(at)) {
+    try {
+      const parts = new Intl.DateTimeFormat("en-US", {
+        timeZone, hourCycle: "h23", year: "numeric", month: "2-digit", day: "2-digit",
+        hour: "2-digit", minute: "2-digit", second: "2-digit",
+      }).formatToParts(new Date(at));
+      const n = (type: string) => Number(parts.find((p) => p.type === type)?.value);
+      return Date.UTC(n("year"), n("month") - 1, n("day"), n("hour") % 24, n("minute"), n("second")) - at;
+    } catch {
+      /* a zone this engine does not know: NaN below */
+    }
+  }
+  return NaN;
+}
+
+/** Long zone label plus its short offset, e.g. "Israel Standard Time (GMT+2)". An engine
+ *  without ECMA-402 has no zone database, so callers omit the supplementary label there. */
+export function formatTimeZoneLabel(date: Date, timeZone: string, locale = "en"): string {
+  if (hasIntl()) {
+    if (!timeZone) return "";
+    try {
+      const parts = new Intl.DateTimeFormat(locale, { timeZone, timeZoneName: "long" }).formatToParts(date);
+      const name = parts.find((part) => part.type === "timeZoneName")?.value || timeZone;
+      const offset = new Intl.DateTimeFormat(locale, { timeZone, timeZoneName: "shortOffset" })
+        .formatToParts(date).find((part) => part.type === "timeZoneName")?.value;
+      return offset ? `${name} (${offset.replace(/:00$/, "")})` : name;
+    } catch {
+      return timeZone;
+    }
+  }
+  return "";
+}

package/templates/salon-spa/tier5-src/_shared/himi-account.ts

@@ -0,0 +1,164 @@
+import { dispatch } from "@himalaya/dispatch";
+// Relative for node resolution (see himi-store.ts note); rewritten off-repo.
+import { displayName, getMyData, initials, type WixMyData } from "@himalaya/wix-users";
+import { getMyMember } from "@himalaya/wix-members";
+import { wixMediaUrl } from "@himalaya/wix-media";
+import { formatDateMedium, formatWeekdayDateTime } from "../_shared/engine-intl.js";
+
+export interface AccountProfile {
+  isMember: boolean;
+  identityLine: string;
+  detailLine: string;
+  memberName: string;
+  memberEmail: string;
+  memberImage: string;
+  memberInitials: string;
+  hasMemberImage: boolean;
+  noMemberImage: boolean;
+}
+
+export interface AccountActivityRow {
+  id: string;
+  title: string;
+  subtitle: string;
+  meta: string;
+  status: string;
+}
+
+export function strOf(arg: unknown): string {
+  if (typeof arg === "string") return arg;
+  const a = arg as { value?: string; text?: string } | undefined;
+  return a?.value ?? a?.text ?? "";
+}
+
+export function titleCase(value?: string): string {
+  return (value || "")
+    .toLowerCase()
+    .split(/[_\s-]+/)
+    .filter(Boolean)
+    .map((part) => part[0].toUpperCase() + part.slice(1))
+    .join(" ");
+}
+
+export function fmtDate(value?: string): string {
+  if (!value) return "";
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return "";
+  return formatDateMedium(date);
+}
+
+export function fmtDateTime(value?: string): string {
+  if (!value) return "";
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return "";
+  return formatWeekdayDateTime(date);
+}
+
+function initialsFromName(value: string): string {
+  const parts = value.trim().split(/\s+/).filter(Boolean);
+  if (!parts.length) return "";
+  const first = parts[0]?.[0] ?? "";
+  const last = parts.length > 1 ? parts[parts.length - 1]?.[0] ?? "" : "";
+  return (first + last).toUpperCase();
+}
+
+function profileImage(data: WixMyData): string {
+  const profile = data.profile as { profileImage?: string; photo?: { url?: string }; imageUrl?: string } | undefined;
+  return profile?.profileImage || profile?.photo?.url || profile?.imageUrl || "";
+}
+
+function profileFromData(data: WixMyData, fallbackEmail = ""): AccountProfile {
+  const email = fallbackEmail || data.email || data.contactEmail || "";
+  const name = displayName(data) || email || "Member";
+  const image = profileImage(data);
+  return {
+    isMember: true,
+    identityLine: "Signed in",
+    detailLine: email || name,
+    memberName: name,
+    memberEmail: email,
+    memberImage: image,
+    memberInitials: initials(data) || initialsFromName(name) || "M",
+    hasMemberImage: !!image,
+    noMemberImage: !image,
+  };
+}
+
+/** The signed-in site member's name and photo from their member record, or undefined when it
+ *  cannot be read or names nobody (the caller then shows the email). */
+async function siteMemberProfile(email: string): Promise<AccountProfile | undefined> {
+  try {
+    const member = (await getMyMember({ fieldsets: ["FULL"] }))?.member;
+    const name = [member?.contact?.firstName, member?.contact?.lastName].map((part) => (part ?? "").trim()).filter(Boolean).join(" ")
+      || (member?.profile?.nickname ?? "").trim();
+    if (!name) return undefined;
+    const image = wixMediaUrl(member?.profile?.photo?.url) || wixMediaUrl(member?.profile?.photo?.id) || "";
+    return {
+      isMember: true,
+      identityLine: "Signed in",
+      detailLine: email || name,
+      memberName: name,
+      memberEmail: email || member?.loginEmail || "",
+      memberImage: image,
+      memberInitials: initialsFromName(name) || "M",
+      hasMemberImage: !!image,
+      noMemberImage: !image,
+    };
+  } catch {
+    return undefined;
+  }
+}
+
+export function guestProfile(detailLine: string): AccountProfile {
+  return {
+    isMember: false,
+    identityLine: "Browsing as a guest",
+    detailLine,
+    memberName: "",
+    memberEmail: "",
+    memberImage: "",
+    memberInitials: "M",
+    hasMemberImage: false,
+    noMemberImage: true,
+  };
+}
+
+export async function signedInEmail(): Promise<string> {
+  try {
+    const identity = await dispatch("himi.wix.memberIdentity") as unknown;
+    const direct = identity as { email?: unknown } | null;
+    const wrapped = identity as { payload?: { email?: unknown } } | null;
+    const email = direct?.email ?? wrapped?.payload?.email;
+    return typeof email === "string" ? email : "";
+  } catch {
+    return "";
+  }
+}
+
+export async function loadMemberProfile(guestDetailLine: string): Promise<AccountProfile> {
+  // `himi.wix.memberIdentity` is the session source of truth. Visitor-scoped
+  // getMyData can still return a site/account nickname (e.g. apptestercoowner)
+  // after sign-out or for anonymous — never treat that as a signed-in member.
+  const storedEmail = await signedInEmail();
+  if (!storedEmail) return guestProfile(guestDetailLine);
+  try {
+    const data = await getMyData();
+    return profileFromData(data, storedEmail);
+  } catch {
+    // The account profile is an owner endpoint: the web host refuses it, and a site member need
+    // not have one. The member's own record (the Members API) still names them.
+    const member = await siteMemberProfile(storedEmail);
+    if (member) return member;
+    return {
+      isMember: true,
+      identityLine: "Signed in",
+      detailLine: storedEmail,
+      memberName: storedEmail,
+      memberEmail: storedEmail,
+      memberImage: "",
+      memberInitials: initialsFromName(storedEmail) || "M",
+      hasMemberImage: false,
+      noMemberImage: true,
+    };
+  }
+}