@wix/himalaya-cli 0.1589.0 → 0.1591.0

package/templates/yoga-studio/tier5-src/himi-events-detail/index.ts

@@ -243,7 +243,7 @@ function tierPrice(t: WixAvailableTicket): string {
   // as "25" — a price that reads as a quantity, and nothing downstream could tell it was a
   // formatting failure. `formatCurrency` uses real Intl where it exists and a symbol-carrying
   // fallback where it does not, diffed against ECMA-402 in engine-intl-fallback.test.ts.
-  return formatCurrency(Number(raw), t.price?.currency || "USD", "en");
+  return formatCurrency(Number(raw), t.price?.currency || "USD");
 }
 
 function tierAvailable(t: WixAvailableTicket): boolean {
@@ -286,7 +286,7 @@ function tierRows(defs: WixAvailableTicket[], selectedId: string): TicketTierRow
         priceAmount: Number(t.price?.amount ?? 0),
         ...(isGuestPrice ? { priceLine: detailCopy("event.payWhatYouWant", "Pay what you want") } : {}),
         ...(isGuestPrice ? { priceAmount: minPrice, isGuestPrice: true } : {}),
-        ...(isGuestPrice ? { minimumPriceLabel: detailCopy("event.minPrice", "Minimum {price}").replace("{price}", formatCurrency(minPrice, t.price?.currency || "USD", "en")) } : {}),
+        ...(isGuestPrice ? { minimumPriceLabel: detailCopy("event.minPrice", "Minimum {price}").replace("{price}", formatCurrency(minPrice, t.price?.currency || "USD")) } : {}),
       };
     });
 }
@@ -399,7 +399,7 @@ function derive(s: S): S {
     noFooterCaption: !s.footerCaption,
     hideFooter: s.status !== "ready" || s.errored || !s.footerLabel || s.rsvpState !== "none",
     checkoutDisabled: count === 0 || count > s.ticketLimitPerOrder || ticketCheckoutInFlight || !ticketCheckoutAllowed || s.ticketTiers.some((row) => row.isGuestPrice && (row.quantity ?? 0) > 0 && (!String(row.guestPrice ?? "").trim() || Number(row.guestPrice) < (row.minPrice ?? 0) || !Number.isFinite(Number(row.guestPrice)))) || s.ticketTiers.some((row) => (row.quantity ?? 0) > (row.maxQuantity ?? 99)),
-    ticketTotal: formatCurrency(total, s.ticketCurrency || "USD", "en"),
+    ticketTotal: formatCurrency(total, s.ticketCurrency || "USD"),
     ticketCountLabel: copyParam("event.ticketCount", "{n} tickets, plus fees").replace("{n}", String(count)),
     noSchedule: s.schedule.length === 0,
     noFullSchedule: s.fullSchedule.length === 0,
@@ -494,7 +494,7 @@ function detailMoney(money?: EventDetailMoney): string {
   if (money?.formattedValue) return money.formattedValue;
   const value = money?.value;
   if (value == null || String(value).trim() === "" || !money?.currency || !Number.isFinite(Number(value))) return "";
-  return formatCurrency(Number(value), money.currency, "en");
+  return formatCurrency(Number(value), money.currency);
 }
 
 function detailPlace(e: WixEvent): { value: string; mapUrl: string; hideMapTap: boolean; icon: string } {
@@ -617,7 +617,7 @@ const svc: ReturnType<typeof defineService<S, DetailActions>> = defineService<S,
     ticketSheetOpen: false,
     rsvpActionsOpen: false,
     cancelConfirmOpen: false,
-    ticketTotal: formatCurrency(0, "USD", "en"),
+    ticketTotal: formatCurrency(0, "USD"),
     ticketCountLabel: copyParam("event.ticketCount", "{n} tickets, plus fees").replace("{n}", "0"),
     checkoutDisabled: true,
     schedule: [],

package/templates/yoga-studio-owner/tier5-src/_shared/app-locale.ts

@@ -0,0 +1,61 @@
+// The language a worker formats numbers, money and plurals in, and the business's time zone. A worker has no host locale to read,
+// so the screen's `onAppear` hands it over: `appear()` adds `locale` to the load params when the app
+// pins its language, and `stashCopy` stores it here. Absent, every formatter stays on "en" — the
+// house pattern every English app was approved with — so an unpinned app is unchanged.
+//
+// The business time zone comes the same way, from the app's provisioning (`businessTimeZone`, collected
+// at migration time while the site's properties are readable): a worker cannot read it itself, because
+// the site-properties route is owner-scoped. Absent, it is "" and no worker guesses one.
+//
+// Pure, no host globals: bundled into every worker that formats, copied into generated templates.
+
+const TAG = /^[A-Za-z]{2,3}(?:-[A-Za-z0-9]{2,8})*$/;
+let tag = "en";
+
+/** Set from a load argument's `locale`; anything that is not a language tag resets to "en". */
+export function setAppLocale(value: unknown): void {
+  tag = typeof value === "string" && TAG.test(value) ? value : "en";
+}
+
+export function appLocale(): string {
+  return tag;
+}
+
+/** An IANA zone such as "Asia/Jerusalem" (or "UTC") that this engine knows. A bare offset, a lowercase
+ *  alias or an engine without ECMA-402 is not one: a zone is never guessed. */
+export function isIanaTimeZone(value: unknown): value is string {
+  if (typeof value !== "string" || !/^(?:UTC|[A-Za-z]+(?:\/[A-Za-z0-9_+-]+)+)$/.test(value)) return false;
+  // An engine without ECMA-402 has no zone database: nothing it holds is a zone it knows.
+  if (typeof Intl === "object" && typeof Intl.DateTimeFormat === "function") {
+    try {
+      new Intl.DateTimeFormat("en-US", { timeZone: value });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+
+let zone = "";
+
+/** Set from a load argument's `businessTimeZone`; anything that is not an IANA zone clears it. */
+export function setBusinessTimeZone(value: unknown): void {
+  zone = isIanaTimeZone(value) ? value : "";
+}
+
+/** The business's IANA zone, or "" when the app has none provisioned. */
+export function businessTimeZone(): string {
+  return zone;
+}
+
+/** Does `count` take the singular form in the app language? CLDR plural rules, so French "0 point"
+ *  and "1,5 point" are singular and Hebrew "2" is not. An engine without PluralRules keeps the
+ *  English rule (exactly one). */
+export function isSingular(count: number, locale = appLocale()): boolean {
+  try {
+    // An engine without ECMA-402 has no `Intl` at all: it keeps the English rule.
+    if (typeof Intl === "object" && typeof Intl.PluralRules === "function") return new Intl.PluralRules(locale).select(count) === "one";
+  } catch { /* malformed tag — use the English rule */ }
+  return count === 1;
+}

package/templates/yoga-studio-owner/tier5-src/_shared/engine-intl.ts

@@ -20,6 +20,8 @@
 // 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";
@@ -189,7 +191,7 @@ const CURRENCY_DIGITS: Record<string, number> = {
 export function formatCurrency(
   amount: number,
   currency = "USD",
-  locale = "en",
+  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,
@@ -258,7 +260,7 @@ function groupThousands(fixed: string): string {
  *     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 = "en"): string {
+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
@@ -409,7 +411,7 @@ export function compareDateDesc(a: string, b: string): number {
 // 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, "en")` — the currency's NATURAL decimals
+// 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

package/templates/yoga-studio-owner/tier5-src/_shared/himi-copy.ts

@@ -12,10 +12,12 @@
 // and every read returns `fallback` verbatim — routing a worker string through
 // copyParam is byte-for-byte behavior-preserving.
 //
-// Pure + Hermes-safe (no host globals, no Node APIs, no imports): bundled into
+// Pure + Hermes-safe (no host globals, no Node APIs; its only import is the pure `app-locale` sibling): bundled into
 // every worker that emits user-facing copy, and copied verbatim into the
 // generated templates' tier5-src/_shared/.
 
+import { isSingular, setAppLocale, setBusinessTimeZone } from "./app-locale.js";
+
 /** Customer strings override every read; translated stock is valid only for its
  * original English fallback. Some existing keys serve more than one message. */
 export type CopyPackValue = string | { source: string; translation: string };
@@ -29,6 +31,12 @@ let copyReceived = false;
  *  stock fallbacks keep rendering. */
 export function stashCopy(arg: unknown): void {
   if (!arg || typeof arg !== "object") return;
+  // A param-carrying dispatch names the app language and business zone too (absent: the English house
+  // pattern, and no zone).
+  if ("copy" in arg || "locale" in arg || "businessTimeZone" in arg) {
+    setAppLocale((arg as Record<string, unknown>).locale);
+    setBusinessTimeZone((arg as Record<string, unknown>).businessTimeZone);
+  }
   const raw = (arg as Record<string, unknown>).copy;
   if (typeof raw !== "string" || !raw) return;
   try {
@@ -77,5 +85,5 @@ export function copyPlural(key: string, fallback: string, count: number): string
   const pattern = copyParam(key, fallback);
   const match = /^\{n, plural, one \{([^{}]*)\} other \{([^{}]*)\}\}$/.exec(pattern);
   if (!match) return copyTemplate(key, fallback, { n: count });
-  return (count === 1 ? match[1] : match[2])!.replace(/#/g, String(count));
+  return (isSingular(count) ? match[1] : match[2])!.replace(/#/g, String(count));
 }