@wix/himalaya-cli 0.1588.0 → 0.1590.0

package/templates/branded-lite/tier5-src/himi-branded-lite-my-groups/index.ts

@@ -0,0 +1,237 @@
+import { defineService } from "@himalaya/state";
+import { getGroup, listMemberships, type WixGroup, type WixGroupMembership } from "@himalaya/wix-groups";
+import { getMyMember } from "@himalaya/wix-members";
+import { copyParam, stashCopy } from "../_shared/himi-copy.js";
+import { groupMemberCount } from "../_shared/group-member-count.js";
+import { groupImage } from "../_shared/himi-media.js";
+import { memberAccess, memberAccessDenied, type MemberAccess } from "../_shared/member-access.js";
+
+// The groups the SIGNED-IN member belongs to (the One App "My groups" list). Two reads, both as the
+// member: the memberships (GET /social-groups-proxy/members/v2/members/{id}/memberships, which Wix
+// answers for the caller's own id only) and then one getGroup per membership, because a membership
+// carries a group id and a role, never the group's name or cover.
+//
+// A visitor makes ZERO calls: the screen shows its sign-in card. The member id is the current
+// member's (`getMyMember`), never taken from input. Read-only and online-only.
+
+type Failure = "forbidden" | "failed";
+
+/** Memberships read in one page. A member with more is told so, not shown a silently short list. */
+const PAGE_LIMIT = 50;
+const DETAIL_SCREEN = "himi_group";
+
+interface MyGroupRow {
+  id: string;
+  title: string;
+  /** "Admin", "Member" or "Pending request" — the member's standing in the group. */
+  statusLabel: string;
+  meta: string;
+  image: string;
+  initial: string;
+  hasImage: boolean;
+  noImage: boolean;
+  detailScreenId: string;
+}
+
+interface State {
+  status: "loading" | "ready" | "error" | "signedOut";
+  rows: MyGroupRow[];
+  emptyText: string;
+  errorText: string;
+  /** Some groups could not be read, or the member has more than one page: said above the list. */
+  partialText: string;
+  notLoading: boolean;
+  notErrored: boolean;
+  noRows: boolean;
+  noEmpty: boolean;
+  noPartial: boolean;
+  needsSignIn: boolean;
+  noSignIn: boolean;
+}
+
+const initial: State = {
+  status: "loading",
+  rows: [],
+  emptyText: "",
+  errorText: "",
+  partialText: "",
+  notLoading: false,
+  notErrored: true,
+  noRows: true,
+  noEmpty: true,
+  noPartial: true,
+  needsSignIn: false,
+  noSignIn: true,
+};
+
+/** Bumped by every load, so a response that arrives after a newer load began is dropped. */
+let loadSeq = 0;
+
+const signedOutState: State = { ...initial, status: "signedOut", notLoading: true, needsSignIn: true, noSignIn: false };
+
+function errorState(failure: Failure): State {
+  return {
+    ...initial,
+    status: "error",
+    notLoading: true,
+    notErrored: false,
+    errorText: failure === "forbidden"
+      ? copyParam("myGroups.forbiddenText", "Your groups are unavailable for this account. Sign in again.")
+      : copyParam("myGroups.errorText", "Your groups could not be loaded."),
+  };
+}
+
+function failureOf(error: unknown): Failure {
+  return memberAccessDenied(error) ? "forbidden" : "failed";
+}
+
+function isNotFound(error: unknown): boolean {
+  return /HTTP 404\b/.test(String((error as Error)?.message ?? error));
+}
+
+function statusLabelOf(membership: WixGroupMembership): string {
+  if ((membership.status ?? "").toUpperCase() === "PENDING") return copyParam("myGroups.status.pending", "Pending request");
+  return (membership.role?.value ?? "").toUpperCase() === "ADMIN"
+    ? copyParam("myGroups.status.admin", "Admin")
+    : copyParam("myGroups.status.member", "Member");
+}
+
+function rowOf(group: WixGroup, membership: WixGroupMembership): MyGroupRow {
+  const title = (group.name || copyParam("groups.groupFallbackName", "Group")).trim();
+  const count = group.membersCount ?? group.memberCount;
+  const image = groupImage(group);
+  return {
+    id: String(membership.groupId),
+    title,
+    statusLabel: statusLabelOf(membership),
+    meta: typeof count === "number" ? groupMemberCount(count) : "",
+    image,
+    initial: (title[0] || "G").toUpperCase(),
+    hasImage: Boolean(image),
+    noImage: !image,
+    detailScreenId: DETAIL_SCREEN,
+  };
+}
+
+/** JOINED and PENDING memberships with a group id; an UNKNOWN status is not a membership to show. */
+function shownMemberships(response: unknown): WixGroupMembership[] | undefined {
+  const memberships = (response as { memberships?: unknown } | null | undefined)?.memberships;
+  if (!Array.isArray(memberships)) return undefined;
+  const seen = new Set<string>();
+  return (memberships as WixGroupMembership[]).filter((m) => {
+    const status = (m?.status ?? "").toUpperCase();
+    if (typeof m?.groupId !== "string" || !m.groupId || (status !== "JOINED" && status !== "PENDING") || seen.has(m.groupId)) return false;
+    seen.add(m.groupId);
+    return true;
+  });
+}
+
+function readyState(rows: MyGroupRow[], partialText: string): State {
+  return {
+    ...initial,
+    status: "ready",
+    rows,
+    emptyText: copyParam("myGroups.emptyText", "You haven’t joined any groups yet."),
+    partialText,
+    notLoading: true,
+    noRows: rows.length === 0,
+    noEmpty: rows.length > 0,
+    noPartial: !partialText,
+  };
+}
+
+const sameMember = (a: MemberAccess, b: MemberAccess) => a.email === b.email && a.scope === b.scope;
+
+/** Whose groups the rows on screen are. A load for anybody else clears them first. */
+let rowsOwner: MemberAccess | undefined;
+
+/** The sign-in card is what the screen shows. A load that finds a member now (they signed in and came back)
+ *  shows the loading state at once instead of leaving the card up over the network calls. A module flag, not
+ *  a read of the state: the reload this starts must not see the card again and restart forever. */
+let showingSignIn = false;
+
+/** The member changed while this load ran or the rows were on screen: show the loading state at once,
+ *  so the previous member's group names and standing are never on screen, and load for the current one. */
+function restart(): State {
+  rowsOwner = undefined;
+  showingSignIn = false;
+  loadSeq++;
+  void svc.load();
+  return { ...initial };
+}
+
+/** An error for THIS member, unless a newer load began or the member left meanwhile: then it is stale. */
+async function failureFor(seq: number, access: MemberAccess, failure: Failure): Promise<State | undefined> {
+  if (seq !== loadSeq) return undefined;
+  const now = await memberAccess();
+  // A newer load began while the identity was read: its answer is the fresher one.
+  if (seq !== loadSeq) return undefined;
+  if (!sameMember(access, now)) return restart();
+  return errorState(failure);
+}
+
+async function loadOnce(access: MemberAccess): Promise<State | undefined> {
+  const seq = ++loadSeq;
+  if (!access.email) { showingSignIn = true; return signedOutState; }
+  try {
+    const me = await getMyMember();
+    const memberId = String(me?.member?.id ?? "");
+    if (!memberId) return failureFor(seq, access, "failed");
+    const response = await listMemberships(memberId, { limit: PAGE_LIMIT });
+    const memberships = shownMemberships(response);
+    if (!memberships) return failureFor(seq, access, "failed");
+    const reads = await Promise.allSettled(memberships.map((m) => getGroup(String(m.groupId))));
+    // Another load began, or the member signed out / switched account while these reads were in
+    // flight: these rows belong to somebody else now.
+    if (seq !== loadSeq) return undefined;
+    const now = await memberAccess();
+    // Re-checked after the await: a newer load may have committed while the identity was read.
+    if (seq !== loadSeq) return undefined;
+    if (!sameMember(access, now)) return restart();
+    const rows: MyGroupRow[] = [];
+    let failed = 0;
+    let firstFailure: unknown;
+    reads.forEach((read, index) => {
+      if (read.status === "fulfilled") {
+        // Social Groups wraps the entity as `{ group }`; the typed signature claims a bare group.
+        const group = ((read.value as unknown as { group?: WixGroup }).group ?? read.value) as WixGroup;
+        if (group && typeof group === "object") { rows.push(rowOf(group, memberships[index])); return; }
+      }
+      // A group deleted since the membership was listed is gone, not a failed read.
+      if (read.status === "rejected" && isNotFound(read.reason)) return;
+      failed++;
+      firstFailure ??= read.status === "rejected" ? read.reason : undefined;
+    });
+    // Memberships exist but not one group could be shown: that is unreadable (a pending request on a
+    // private group answers 404 until approved) or gone, never "you have no groups".
+    if (memberships.length > 0 && rows.length === 0) return errorState(failed > 0 ? failureOf(firstFailure) : "failed");
+    // Wix omits `total` when it is too many to count, and says so in `tooManyToCount`.
+    const truncated = response.metadata?.tooManyToCount === true || Number(response.metadata?.total ?? 0) > PAGE_LIMIT;
+    const partialText = [
+      failed > 0 ? copyParam("myGroups.partialText", "Some of your groups could not be loaded.") : "",
+      truncated ? copyParam("myGroups.truncatedText", "Showing your first groups only.") : "",
+    ].filter(Boolean).join(" ");
+    rowsOwner = access;
+    return readyState(rows, partialText);
+  } catch (error) {
+    // A request that rejects because the member left is the old member's error, not the current one's.
+    return failureFor(seq, access, failureOf(error));
+  }
+}
+
+const svc = defineService<State, {
+  load: (state: State, arg?: unknown) => Promise<State | undefined>;
+}>("himiBrandedMyGroups", {
+  state: initial,
+  actions: {
+    load: async (_state, arg) => {
+      stashCopy(arg);
+      const access = await memberAccess();
+      if ((rowsOwner && !sameMember(rowsOwner, access)) || (showingSignIn && access.email)) return restart();
+      return loadOnce(access);
+    },
+  },
+});
+
+svc.load();
+export { svc };

package/templates/branded-lite/tier5-src/himi-branded-lite-plans/index.ts

@@ -82,7 +82,7 @@ function money(plan: WixPlan): string {
   const raw = price?.value;
   if (raw == null || raw === "" || Number.isNaN(Number(raw))) return "";
   try {
-    return formatCurrency(Number(raw), price?.currency || "USD", "en");
+    return formatCurrency(Number(raw), price?.currency || "USD");
   } catch {
     return `${raw}`;
   }

package/templates/branded-lite/tier5-src/himi-branded-lite-program/index.ts

@@ -147,7 +147,7 @@ function priceOf(p: WixProgram): string {
   if (raw == null || raw === "" || Number.isNaN(Number(raw))) return "";
   if (Number(raw) === 0) return "";
   try {
-    return formatCurrency(Number(raw), price?.currency || "USD", "en");
+    return formatCurrency(Number(raw), price?.currency || "USD");
   } catch {
     return `${raw}`;
   }

package/templates/branded-lite/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/branded-lite/tier5-src/wix-spaces-member-detail/index.ts

@@ -42,8 +42,12 @@ function name(m: WixMember): string {
 function followLabelFor(isFollowing: boolean): string {
   return isFollowing ? "Following ✓" : "Follow";
 }
+/** Each counter on its own: a missing one is hidden, never shown as 0, and an explicit 0 stays visible. */
 function followCountFor(followers: number | null, following: number | null): string {
-  return followers === null || following === null ? "" : followers + " Followers · " + following + " Following";
+  return [
+    followers === null ? "" : followers + (followers === 1 ? " Follower" : " Followers"),
+    following === null ? "" : following + " Following",
+  ].filter(Boolean).join(" · ");
 }
 
 const INITIAL: S = {

package/templates/brandy/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/brandy/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));
 }

package/templates/community-club/config.ts

@@ -231,6 +231,13 @@ export default defineApp({
         "parentScreenId": "himi_group",
         "tabId": "groups"
       },
+      {
+        "screenId": "himi_my_groups",
+        "isPublic": true,
+        "paramKeys": [],
+        "parentScreenId": "himi_groups",
+        "tabId": "groups"
+      },
       {
         "screenId": "himi_cms",
         "isPublic": true,