@wix/himalaya-cli 0.1582.0 → 0.1584.0

package/templates/community-club/tier5-src/himi-branded-lite-notifsettings/index.ts

@@ -0,0 +1,173 @@
+import { withOnlineWrites } from "../_shared/online-actions.js";
+// himi-branded-lite-notifsettings — reads the site's notification topics + the member's preferences.
+// a failed query is an error with Retry (or Sign in when Wix refuses the
+// visitor) and an empty one is a real empty state — never sample rows presented as
+// the customer's own. Samples appear only in the host's explicit sample preview
+// (_shared/branded-load-state.ts).
+// any exist. INTERACTIVE: tapping a row toggles that topic On/Off — optimistic +
+// best-effort upsertMyNotificationPreferences (a no-op on sample rows).
+import { defineService as registerService } from "@himalaya/state";
+import { withEmptyFlags } from "../_shared/empty-flags.js";
+import { stashCopy } from "../_shared/himi-copy.js";
+import { memberAccess, assertMemberAccess, type MemberAccess } from "../_shared/member-access.js";
+import { LOADING, loaded, loadFailed, type LoadCopy, type LoadFlags } from "../_shared/branded-load-state.js";
+import {
+  getNotificationTopics,
+  getMyNotificationPreferences,
+  upsertMyNotificationPreferences,
+  muteStatusFor,
+  readTopics,
+  readPreferences,
+  isDeliveredNow,
+  isLocked,
+  preferenceFor,
+  type NotificationTopicDefinition,
+  type PreferenceInfo,
+} from "@himalaya/wix-notification-preferences";
+
+/** The channel this surface delivers on — read for the row state, written on toggle.
+ *  One constant, so the read and the write cannot drift apart. */
+const CHANNEL = "MOBILE";
+
+/** `note` is the line under a row's switch — only a locked topic has one. */
+interface Row { id: string; name: string; subtitle: string; note: string; on: boolean; locked: boolean;
+  /** Inverse of `locked` (hiddenWhen hides on TRUE) and the plain On/Off a locked row shows. */
+  notLocked: boolean; stateLabel: string }
+interface S extends LoadFlags {
+  preferencesMember: MemberAccess | null;
+  topics: Row[]; emptyText: string; actionMessage: string;
+  isMock: boolean; notMock: boolean; /** #2849 — hiddenWhen() hides on TRUE, so these are inverted: the empty-state banner
+   *  shows only when the site really has none, and the unavailable one only when the
+   *  query failed. A failed query must never render the sentence that claims the
+   *  customer has no content. */
+  notMockEmpty: boolean; notMockUnavailable: boolean;
+}
+
+/** Whether this topic is actually being DELIVERED — not merely what the recipient
+ *  asked for. `isDeliveredNow` prefers the server's `granted` verdict, so a topic the
+ *  member unmuted under a channel-wide mute renders OFF instead of promising a
+ *  notification that will never arrive. No preference row at all ⇒ the topic's default,
+ *  which is delivery. */
+function isOn(topicId: string, prefs: PreferenceInfo[]): boolean {
+  const p = preferenceFor(topicId, prefs, CHANNEL);
+  if (!p) return true;
+  return isDeliveredNow(p.stateData);
+}
+
+/** A row the server says cannot be changed here (a broader rule overrides it). */
+function locked(topicId: string, prefs: PreferenceInfo[]): boolean {
+  return isLocked(preferenceFor(topicId, prefs, CHANNEL)?.stateData);
+}
+
+/** Row subtitle doubles as an affordance: current state + how to change it. */
+function subtitleFor(on: boolean): string {
+  return on ? "On · tap to mute" : "Off · tap to enable";
+}
+
+function row(id: string, name: string, on: boolean): Row {
+  return { id, name, subtitle: subtitleFor(on), note: "", on, locked: false, notLocked: true, stateLabel: on ? "On" : "Off" };
+}
+
+function norm(t: NotificationTopicDefinition, prefs: PreferenceInfo[]): Row {
+  const name = (t.displayName || "Notification").trim() || "Notification";
+  const id = t.topicId || name;
+  const r = row(id, name, isOn(id, prefs));
+  // An overridden row says so instead of offering a toggle that cannot take effect.
+  return locked(id, prefs)
+    ? { ...r, locked: true, notLocked: false, subtitle: "Managed by your channel settings", note: "Managed by your channel settings" }
+    : r;
+}
+
+const MOCK: Row[] = [
+  row("sample-orders", "Order updates", true),
+  row("sample-bookings", "Bookings & reminders", true),
+  row("sample-promos", "Promotions & offers", false),
+  row("sample-community", "Community activity", true),
+];
+
+/** sample rows reach the screen ONLY in the host's explicit sample preview;
+ *  a failed or empty query is an honest error / empty state (branded-load-state.ts). */
+const COPY: LoadCopy<Row> = {
+  prefix: "notifsettings",
+  empty: "No notification topics to manage yet.",
+  error: "Notification settings couldn't be loaded.",
+  signIn: "Sign in to manage your notifications.",
+  sample: () => MOCK.map((r) => ({ ...r })),
+};
+
+const defineService = withOnlineWrites(registerService, ["toggle"], { messageFields: ["actionMessage"] });
+const INITIAL = { ...LOADING, topics: [] as Row[], emptyText: "", actionMessage: "", preferencesMember: null };
+const signInRequired = () => new Error("Unauthenticated: sign in to manage notifications");
+let loadVersion = 0;
+const svc = defineService<S, {
+  prepare: (s: S) => S;
+  load: (s: S, arg?: unknown) => Promise<S | undefined>;
+  toggle: (s: S, p?: { id?: string; value?: unknown }) => Promise<S | undefined>;
+}>("himiBrandedNotifSettings", withEmptyFlags({
+  state: INITIAL,
+  actions: {
+    prepare: (s) => ({ ...s, ...INITIAL }),
+    load: async (s, arg): Promise<S | undefined> => {
+      stashCopy(arg);
+      const version = ++loadVersion;
+      await svc.prepare();
+      try {
+        const member = await memberAccess();
+        if (!member.email) throw signInRequired();
+        const [topicsRes, prefsRes] = await Promise.all([
+          getNotificationTopics(),
+          getMyNotificationPreferences(),
+        ]);
+        await assertMemberAccess(member);
+        const prefs = readPreferences(prefsRes);
+        const topics = readTopics(topicsRes).map((t) => norm(t, prefs));
+        return version === loadVersion ? { ...s, ...loaded("topics", topics, COPY), preferencesMember: member, actionMessage: "" } : undefined;
+      } catch {
+        const member = await memberAccess();
+        // An authenticated denial is not repaired by an endless sign-in loop.
+        const failure = member.email ? new Error(COPY.error) : signInRequired();
+        return version === loadVersion ? { ...s, ...loadFailed("topics", failure, COPY), preferencesMember: null, actionMessage: "" } : undefined;
+      }
+    },
+    // Flip one topic's On/Off. Optimistic (updates the row immediately); the real
+    // upsert is best-effort and a no-op on sample rows.
+    toggle: async (s, p): Promise<S | undefined> => {
+      const id = p?.id;
+      const target = s.topics.find((r) => r.id === id);
+      if (s.busy || !id || !target || target.locked) return undefined;
+      if (!s.isMock) {
+        try {
+          if (!s.preferencesMember) return undefined;
+          await assertMemberAccess(s.preferencesMember);
+          if (svc.getState().preferencesMember !== s.preferencesMember) return undefined;
+        } catch {
+          await svc.load();
+          return undefined;
+        }
+      }
+      let nextOn = true;
+      const topics = s.topics.map((r) => {
+        if (r.id !== id) return r;
+        // A Toggle sends the NEXT state as `value` (action-payload contract); honour it so
+        // a repeated event can never flip the row the wrong way. A bare tap still flips.
+        nextOn = typeof p?.value === "boolean" ? p.value : !r.on;
+        return { ...r, on: nextOn, subtitle: subtitleFor(nextOn), stateLabel: nextOn ? "On" : "Off" };
+      });
+      if (!s.isMock && !id.startsWith("sample-")) {
+        try {
+          // `stateData.state` is a SCALAR enum — the old nested `{ muteStatus }` was a
+          // shape this service does not have, so every write was malformed.
+          await upsertMyNotificationPreferences([
+            { topicId: id, channel: CHANNEL, stateData: { state: muteStatusFor(nextOn) } },
+          ]);
+        } catch { /* keep the optimistic state */ }
+        try { await assertMemberAccess(s.preferencesMember!); }
+        catch { await svc.load(); return undefined; }
+      }
+      return svc.getState().preferencesMember === s.preferencesMember ? { ...svc.getState(), topics } : undefined;
+    },
+  },
+}, { topics: "noTopics" }));
+svc.prepare();
+svc.load();
+export { svc };

package/templates/community-club/tier5-src/himi-events-detail/index.ts

@@ -35,8 +35,10 @@ import {
   type EventRow,
 } from "../_shared/himi-events";
 import { stashCopy, copyParam } from "../_shared/himi-copy.js";
+import { eventPageUrlOf, eventStatus, registrationKindOf, registrationUi, registrationUrlOf, type RegistrationKind } from "../_shared/event-registration.js";
+export { eventPageUrlOf, registrationKindOf, registrationUrlOf, type RegistrationKind };
 import { openRichLink } from "../_shared/rich-content-link.js";
-import { richBody } from "../_shared/rich-body.js";
+import { descriptionBody } from "../_shared/rich-body.js";
 import { mayUseRegularTicketCheckout } from "../_shared/iap-attendance.js";
 import { ATTENDANCE_INITIAL, ATTENDANCE_NOT_HYDRATED, createAttendancePurchase, type AttendancePurchaseFields } from "../_shared/iap-attendance-purchase.js";
 import { resetUnhydratedKeysOnOlderRuntime } from "../_shared/iap-worker.js";
@@ -88,9 +90,6 @@ interface TicketTierRow {
   notAvailable?: boolean;
 }
 
-/** Registration CTA kind derived from the event's registration/eventType. */
-export type RegistrationKind = "rsvp" | "tickets" | "external" | "none";
-
 // Offline-first (data-offline): the event detail is a read-through single-item read —
 // it shares the `events` entity written by the list, and also write-throughs its own
 // fetched row so a deep-linked detail is cached for the next offline open. On a failed
@@ -302,7 +301,7 @@ function loadedTiers(defs: WixAvailableTicket[]): { rows: TicketTierRow[]; ticke
       const ticket = tickets.get(row.ticketDefinitionId ?? row.id);
       if (!ticket) return { ...row, quantity: 0, description: "", feeNote: "", policy: "", noPolicy: true, notAvailable: !row.available, notGuestPrice: !row.isGuestPrice, maxQuantity: 0 };
       const policy = (ticket as unknown as { policy?: string; policyText?: string }).policyText || (ticket as unknown as { policy?: string }).policy || "";
-      return { ...row, quantity: 0, description: ticket.description || "", feeNote: ((ticket as unknown as { wixFeeConfig?: { type?: string }; feeType?: string }).wixFeeConfig?.type ?? (ticket as unknown as { feeType?: string }).feeType) === "FEE_ADDED_AT_CHECKOUT" ? detailCopy("event.serviceFee", "+ ticket service fee") : "", policy, noPolicy: !policy, notAvailable: !row.available, notGuestPrice: !row.isGuestPrice, priceAmount: row.priceAmount ?? Number(ticket.price?.amount ?? 0), rowLimit: row.available ? ticket.limitPerCheckout ?? 99 : 0, maxQuantity: row.available ? ticket.limitPerCheckout ?? 99 : 0 };
+      return { ...row, quantity: 0, description: descriptionBody(ticket.description).bodyText, feeNote: ((ticket as unknown as { wixFeeConfig?: { type?: string }; feeType?: string }).wixFeeConfig?.type ?? (ticket as unknown as { feeType?: string }).feeType) === "FEE_ADDED_AT_CHECKOUT" ? detailCopy("event.serviceFee", "+ ticket service fee") : "", policy, noPolicy: !policy, notAvailable: !row.available, notGuestPrice: !row.isGuestPrice, priceAmount: row.priceAmount ?? Number(ticket.price?.amount ?? 0), rowLimit: row.available ? ticket.limitPerCheckout ?? 99 : 0, maxQuantity: row.available ? ticket.limitPerCheckout ?? 99 : 0 };
     });
     return { rows, tickets };
 }
@@ -451,29 +450,6 @@ function calendarFallbackUrl(s: S, end: number): string {
  *  shortDescription: REGISTRATION fills eventType, which skips the query enrichment that used to supply them. */
 export const EVENT_DETAIL_FIELDSETS: WixEventFieldset[] = ["DETAILS", "TEXTS", "REGISTRATION", "URLS", "FORM", "AGENDA"];
 
-/** Map registration status and decoded eventType onto the CTA variant. The decoded
- *  `eventType` already folds registration.type / registration.initialType /
- *  the legacy flat `type` (decodeEvent, #478). Without a recognized type or
- *  status there is no registration action to offer. */
-export function registrationKindOf(e: WixEvent): RegistrationKind {
-  const raw = e as unknown as { registration?: { type?: string; initialType?: string; status?: string } };
-  const value = (raw.registration?.type ?? e.eventType ?? raw.registration?.initialType ?? "").toUpperCase();
-  if (value === "NONE" || value.includes("NO_REGISTRATION")) return "none";
-  // Open statuses select the footer action, so they must also select the
-  // inventory read and action guards when type metadata is absent or stale.
-  switch (raw.registration?.status?.toUpperCase()) {
-    case "OPEN_TICKETS": return "tickets";
-    case "OPEN_EXTERNAL": return "external";
-    case "OPEN_RSVP":
-    case "OPEN_RSVP_WAITLIST_ONLY":
-    case "SCHEDULED_RSVP": return "rsvp";
-  }
-  if (value.includes("EXTERNAL")) return "external";
-  if (value.includes("TICKET")) return "tickets";
-  if (value.includes("RSVP")) return "rsvp";
-  return "none";
-}
-
 function detailCopy(key: string, fallback: string): string { return copyParam(key, fallback); }
 
 function detailDate(e: WixEvent): { line: string; zone: string; start: number; end: number } {
@@ -536,69 +512,17 @@ function detailPlace(e: WixEvent): { value: string; mapUrl: string; hideMapTap:
   return { value, mapUrl: mapped, hideMapTap: !mapped, icon: "location" };
 }
 
-function eventStatus(e: WixEvent): string {
-  const raw = e as unknown as { status?: string };
-  return (raw.status ?? e.eventStatus ?? "").toUpperCase();
-}
-
-function registrationUi(e: WixEvent, now: number): { state: string; label: string; action: string; caption: string; notice: string } {
-  const raw = e as unknown as { registration?: { status?: string; registrationPaused?: boolean; registrationDisabled?: boolean; allowedGuestTypes?: string; rsvp?: { startDate?: string }; tickets?: { soldOut?: boolean }; external?: { url?: string } }; form?: { messages?: { registrationClosed?: { message?: string; exploreEventsActionLabel?: string }; ticketsUnavailable?: { message?: string; exploreEventsActionLabel?: string } } } };
-  const r = raw.registration ?? {};
-  const status = eventStatus(e);
-  const type = registrationKindOf(e);
-  if (status === "CANCELED") return { state: "notice", label: "", action: "", caption: "", notice: detailCopy("event.canceledNotice", "This event was canceled.") };
-  if (status === "ENDED") return { state: "notice", label: "", action: "", caption: "", notice: detailCopy("event.endedNotice", "This event has ended.") };
-  if (type === "none" || r.registrationDisabled) return { state: "none", label: "", action: "", caption: "", notice: "" };
-  const ownerClosed = raw.form?.messages?.registrationClosed?.message;
-  const ownerSold = raw.form?.messages?.ticketsUnavailable?.message;
-  if (["CLOSED_AUTOMATICALLY", "CLOSED_MANUALLY"].includes(r.status || "") || r.registrationPaused) return { state: "notice", label: "", action: "", caption: "", notice: ownerClosed || detailCopy("event.closedNotice", "Registration is closed.") };
-  if (type === "tickets" && r.tickets?.soldOut) return { state: "notice", label: "", action: "", caption: "", notice: ownerSold || detailCopy("event.soldOutNotice", "Tickets are sold out.") };
-  if (r.status === "SCHEDULED_RSVP") return { state: "scheduled", label: detailCopy("event.rsvpCta", "RSVP"), action: "", caption: detailCopy("event.opensCaption", "RSVP opens {date}.").replace("{date}", r.rsvp?.startDate ? formatWeekdayDateTime(new Date(r.rsvp.startDate)) : ""), notice: "" };
-  if (r.status === "OPEN_RSVP_WAITLIST_ONLY") return { state: "waitlist", label: detailCopy("event.waitlistCta", "Join Waitlist"), action: "himi.open", caption: detailCopy("event.fullCaption", "This event is full."), notice: "" };
-  if (r.status === "OPEN_TICKETS" || type === "tickets") return { state: "tickets", label: detailCopy("event.ticketsCta", "Buy Tickets"), action: "openTickets", caption: "", notice: "" };
-  if (r.status === "OPEN_EXTERNAL" || type === "external") return registrationUrlOf(e)
-    ? { state: "external", label: detailCopy("event.externalCta", "Register"), action: "openRegistration", caption: "", notice: "" }
-    : { state: "none", label: "", action: "", caption: "", notice: "" };
-  if (type === "rsvp" && r.status === "OPEN_RSVP") return { state: "rsvp", label: detailCopy("event.rsvpCta", "RSVP"), action: "himi.open", caption: "", notice: "" };
-  if (r.status === "OPEN_RSVP" || (type === "rsvp" && !r.status)) return { state: "rsvp", label: detailCopy("event.rsvpCta", "RSVP"), action: "himi.open", caption: "", notice: "" };
-  void now;
-  return { state: "none", label: "", action: "", caption: "", notice: "" };
-}
-
-/** External registration URL / event page URL from the raw payload ("" when absent). */
-export function registrationUrlOf(e: WixEvent): string {
-  const raw = e as unknown as {
-    registration?: { external?: { registration?: string; url?: string } };
-    eventPageUrl?: { base?: string; path?: string } | string;
-  };
-  const external = raw.registration?.external?.registration ?? raw.registration?.external?.url;
-  if (typeof external === "string" && /^https?:\/\//i.test(external)) return external;
-  return eventPageUrlOf(e);
-}
-
 /** Event slug for createRedirectSession({ eventsCheckout }) — "" when absent. */
 export function eventSlugOf(e: WixEvent): string {
   const slug = e.slug ?? (e as unknown as { slug?: string }).slug;
   return typeof slug === "string" ? slug.trim() : "";
 }
 
-/** The event's public page URL when the payload carries one ("" otherwise). */
-export function eventPageUrlOf(e: WixEvent): string {
-  const raw = e as unknown as { eventPageUrl?: { base?: string; path?: string } | string };
-  const page = raw.eventPageUrl;
-  if (typeof page === "string" && /^https?:\/\//i.test(page)) return page;
-  if (page && typeof page === "object" && typeof page.base === "string" && page.base) {
-    const path = typeof page.path === "string" ? page.path : "";
-    return `${page.base.replace(/\/$/, "")}${path && !path.startsWith("/") ? "/" : ""}${path}`;
-  }
-  return "";
-}
-
 /** The description pair: the v3 Ricos `description` for RichContent, and its plain text. A string description
  *  (or none) keeps `eventDescription`'s legacy read, with no document. */
 function eventBody(e: WixEvent): { description: string; descriptionJson: string } {
-  const legacy = eventDescription(e);
-  const { bodyJson, bodyText } = richBody((e as unknown as { description?: unknown }).description, legacy);
+  const legacy = eventDescription({ ...e, description: undefined });
+  const { bodyJson, bodyText } = descriptionBody((e as unknown as { description?: unknown }).description, descriptionBody(legacy).bodyText);
   return { description: bodyText, descriptionJson: bodyJson };
 }
 
@@ -1132,6 +1056,8 @@ const svc: ReturnType<typeof defineService<S, DetailActions>> = defineService<S,
             }).sort((a, b) => (eventStartMillis(a) ?? 0) - (eventStartMillis(b) ?? 0)).map((item) => ({ id: item.id ?? "", date: eventWhen(item) })).filter((item) => !!item.id);
           } catch { moreDates = []; optionalReadFailed = true; }
         }
+        const body = eventBody(e);
+        const shortDescription = descriptionBody(rawEvent.shortDescription).bodyText;
         const readyState = derive({
           ...s,
           status: "ready",
@@ -1153,9 +1079,9 @@ const svc: ReturnType<typeof defineService<S, DetailActions>> = defineService<S,
           price,
           zone: dates.zone,
           mapUrl: place.mapUrl,
-          shortDescription: rawEvent.shortDescription || "",
-          noShortDescription: !rawEvent.shortDescription || rawEvent.shortDescription === eventBody(e).description,
-          noDescription: !eventBody(e).description && !eventBody(e).descriptionJson,
+          shortDescription,
+          noShortDescription: !shortDescription || shortDescription === body.description,
+          noDescription: !body.description && !body.descriptionJson,
           noDate: !dates.line,
           registrationState: registration.state,
           footerLabel: registration.label,
@@ -1177,7 +1103,7 @@ const svc: ReturnType<typeof defineService<S, DetailActions>> = defineService<S,
           noMoreDates: moreDates.length === 0,
           // The Ricos description when the event has one (its own text is the plain copy); the legacy
           // string fields otherwise.
-          ...eventBody(e),
+          ...body,
           image,
           hasImage: !!image,
           noImage: !image,

package/templates/community-club/tier5-src/himi-events-list/index.ts

@@ -5,6 +5,8 @@ import { getAll, upsert, type DbEntity } from "@himalaya/local-db";
 import { normalizeEvent, type EventRow } from "../_shared/himi-events";
 import { offsetPage } from "../_shared/offset-page.js";
 import { copyParam } from "../_shared/himi-copy.js";
+import { eventPageUrlOf, registrationUi } from "../_shared/event-registration.js";
+import { share as shareSheet } from "@himalaya/share";
 
 // Offline-first (data-offline): the public events list is a read-through catalog —
 // paint the last-synced rows from the on-device store first (instant, works offline),
@@ -13,8 +15,37 @@ import { copyParam } from "../_shared/himi-copy.js";
 // (+ declared the `events` entity in its dataSchema) just falls back to today's
 // online-only path — the try/catch is the seam that keeps this shared bundle safe.
 const ENTITY = "events";
-async function readCached(): Promise<EventRow[]> {
-  try { return (await getAll(ENTITY)) as unknown as EventRow[]; } catch { return []; }
+interface ListEventRow extends EventRow {
+  dateBadge: string; noDateBadge: boolean;
+  /** This card's verb (Register / RSVP / Buy Tickets / Join Waitlist) from the SAME rule the detail uses; hidden when none applies. */
+  actionLabel: string; noAction: boolean;
+  /** The event page URL (when the payload carries one) for Share. */
+  shareUrl: string;
+}
+
+// The day monogram is a title initial for undated events. Only an actual calendar
+// date becomes a badge; derive it for old cached rows too, without a cache migration.
+// The month must be the three-letter abbreviation: rows cached by an older worker on an
+// Intl-less engine can hold a whole "11/10/2030, 12:00:00 PM" there.
+function withDateBadge(row: EventRow): ListEventRow {
+  const dated = typeof row.month === "string" && /^[A-Z]{3}$/.test(row.month)
+    && /^(?:[1-9]|[12]\d|3[01])$/.test(row.day);
+  const known = row as Partial<ListEventRow>;
+  // Rows cached by an older build carry no registration data: they show no verb until a refresh, never a wrong one.
+  return { ...row, dateBadge: dated ? `${row.day}\n${row.month}` : "", noDateBadge: !dated,
+    actionLabel: known.actionLabel ?? "", noAction: known.noAction ?? true, shareUrl: known.shareUrl ?? "" };
+}
+
+/** The card's action, from the event's own registration (REGISTRATION + URLS fieldsets). Cancelled, ended,
+ *  closed, sold-out and registration-less events offer none, so a card never promises "Register" the detail refuses. */
+function withRegistration(raw: WixEvent, row: ListEventRow): ListEventRow {
+  const ui = registrationUi(raw, Date.now());
+  const offers = ui.state !== "notice" && ui.state !== "none" && ui.state !== "scheduled" && !!ui.label;
+  return { ...row, actionLabel: offers ? ui.label : "", noAction: !offers, shareUrl: eventPageUrlOf(raw) };
+}
+
+async function readCached(): Promise<ListEventRow[]> {
+  try { return ((await getAll(ENTITY)) as unknown as EventRow[]).map(withDateBadge); } catch { return []; }
 }
 async function writeCached(rows: EventRow[]): Promise<void> {
   try { for (const r of rows) await upsert(ENTITY, r as unknown as DbEntity); } catch { /* capability not granted → online-only */ }
@@ -22,12 +53,12 @@ async function writeCached(rows: EventRow[]): Promise<void> {
 
 interface S {
   status: "loading" | "ready";
-  query: string; all: EventRow[]; results: EventRow[]; emptyText: string; countLabel: string;
+  query: string; all: ListEventRow[]; results: ListEventRow[]; emptyText: string; countLabel: string;
   errored: boolean; notErrored: boolean; isLoading: boolean; notLoading: boolean; noEmpty: boolean;
   nextCursor?: string; complete?: boolean; total?: number; loadingMore?: boolean; pageError?: boolean; fromCache?: boolean;
 }
 let queryNow = new Date().toISOString();
-const svc = defineBackendCollection<S, EventRow>("himiEvents", {
+const svc = defineBackendCollection<S, ListEventRow>("himiEvents", {
   restorePagesOnLoad: true,
   state: { status: "loading", query: "", all: [], results: [], emptyText: "", countLabel: "", errored: false, notErrored: true,
     isLoading: true, notLoading: false, noEmpty: true },
@@ -62,10 +93,10 @@ const svc = defineBackendCollection<S, EventRow>("himiEvents", {
         ];
       }
       if (criteria.filter === "value:Past") filter["dateAndTimeSettings.startDate"] = { $lt: queryNow };
-      const res = await queryEvents({ limit: 50, offset: Number(cursor || 0), query: { filter,
+      const res = await queryEvents({ limit: 50, offset: Number(cursor || 0), fields: ["DETAILS", "REGISTRATION", "URLS"], query: { filter,
         sort: [{ fieldName: criteria.sort === "default" ? "dateAndTimeSettings.startDate" : "title", order: criteria.sort === "za" ? "DESC" : "ASC" }, { fieldName: "id", order: "ASC" }] } });
       const raw = res.events ?? [];
-      const items = raw.filter(row => !!row.id).map(normalizeEvent);
+      const items = raw.filter(row => !!row.id).map(row => withRegistration(row, withDateBadge(normalizeEvent(row))));
       await writeCached(items);
       const metadata = (res as { pagingMetadata?: { total?: number } }).pagingMetadata;
       return { items, ...offsetPage(cursor, raw.length, 50, metadata), metadata: { fromCache: false } };
@@ -78,6 +109,16 @@ const svc = defineBackendCollection<S, EventRow>("himiEvents", {
       fromCache: page.metadata?.fromCache === true, errored, notErrored: !errored, isLoading: loading, notLoading: !loading,
       noEmpty: true, countLabel: "", emptyText: errored ? copyParam("events.errorText", "Events could not be loaded.") : "" };
   },
+  actions: {
+    // Share a card's event: its title and date line, plus the event page when the payload carried one.
+    share: async (s, arg) => {
+      const id = typeof arg === "string" ? arg : String((arg as { id?: unknown } | undefined)?.id ?? "");
+      const row = s.results.find(item => item.id === id);
+      if (!row) return undefined;
+      try { await shareSheet({ subject: row.title, text: [row.title, row.dateLine].filter(Boolean).join(" — "), ...(row.shareUrl ? { url: row.shareUrl } : {}) }); } catch { /* the sheet is best-effort: nothing to undo */ }
+      return undefined;
+    },
+  },
 });
 svc.load();
 export { svc };

package/templates/community-club/tier5-src/wix-spaces-whats-new/index.ts

@@ -1,3 +1,4 @@
+import { descriptionBody } from "../_shared/rich-body.js";
 // Tier-5 bundle: Wix Spaces clone — What's New (ON-DEVICE, account-level).
 import { defineService } from "@himalaya/state";
 import { withEmptyFlags } from "../_shared/empty-flags.js";
@@ -8,7 +9,7 @@ interface S { status: "loading" | "ready"; items: Row[]; emptyText: string; /**
 
 function norm(a: WixAnnouncement, i: number): Row {
   const aa = a as unknown as { id?: string; title?: string; bodyText?: string; description?: string };
-  return { id: aa.id || `a${i}`, name: aa.title || "Announcement", subtitle: aa.description || aa.bodyText || "" };
+  return { id: aa.id || `a${i}`, name: aa.title || "Announcement", subtitle: descriptionBody(aa.description, descriptionBody(aa.bodyText).bodyText).bodyText };
 }
 
 const svc = defineService<S, { load: (s: S) => Promise<S> }>("spacesWhatsNew", withEmptyFlags({

package/templates/community-club-owner/dev/index.ts

@@ -81717,6 +81717,51 @@ const TEMPLATED: { pattern: string; display: string; liveSeed?: LiveSeed; static
                         }
                       }
                     },
+                    {
+                      "id": "product_body",
+                      "body": {
+                        "package": "himalaya",
+                        "type": "RichContent",
+                        "props": {
+                          "documentJsonPath": "$service:himiOwnerLiteProduct.bodyJson",
+                          "onLink": {
+                            "actionId": "tier5.himiOwnerLiteProduct.openLink"
+                          },
+                          "fallback": {
+                            "id": "",
+                            "body": {
+                              "package": "himalaya",
+                              "type": "Text",
+                              "props": {
+                                "text": "$service:himiOwnerLiteProduct.bodyText",
+                                "style": "body",
+                                "color": "textPrimary",
+                                "collapseWhenEmpty": true
+                              }
+                            }
+                          }
+                        }
+                      },
+                      "modifiers": {
+                        "hiddenPath": "$service:himiOwnerLiteProduct.noBodyJson"
+                      }
+                    },
+                    {
+                      "id": "product_body_text",
+                      "body": {
+                        "package": "himalaya",
+                        "type": "Text",
+                        "props": {
+                          "text": "$service:himiOwnerLiteProduct.bodyText",
+                          "style": "body",
+                          "color": "textPrimary",
+                          "collapseWhenEmpty": true
+                        }
+                      },
+                      "modifiers": {
+                        "hiddenPath": "$service:himiOwnerLiteProduct.hasBodyJson"
+                      }
+                    },
                     {
                       "id": "product_info_card",
                       "body": {
@@ -82139,7 +82184,8 @@ const TEMPLATED: { pattern: string; display: string; liveSeed?: LiveSeed; static
       "contentType": "application/javascript+ts-bundle",
       "declaredCapabilities": [
         "wix_api",
-        "local_database"
+        "local_database",
+        "open_url"
       ],
       "minBinaryVersion": "0.1.0",
       "bundleVersion": "0.0.1"
@@ -82743,6 +82789,9 @@ const TEMPLATED: { pattern: string; display: string; liveSeed?: LiveSeed; static
                             }
                           }
                         }
+                      },
+                      "modifiers": {
+                        "hiddenPath": "$service:himiOwnerLiteEvent.noBodyJson"
                       }
                     },
                     {
@@ -83752,6 +83801,9 @@ const TEMPLATED: { pattern: string; display: string; liveSeed?: LiveSeed; static
                             }
                           }
                         }
+                      },
+                      "modifiers": {
+                        "hiddenPath": "$service:himiOwnerLitePost.noBodyJson"
                       }
                     },
                     {

package/templates/community-club-owner/tier5-src/_shared/collection-contract.ts

@@ -19,6 +19,8 @@ export interface CollectionConfig {
   /** Numeric 0–5 row field rendered as a Rating (accessible "N out of 5") instead of
    *  folding a "★★★★☆" glyph string into the metadata line, so screen readers get a value. */
   rating?: string;
+  /** Domain-provided calendar text and its unavailable flag, kept separate from media. */
+  dateBadge?: { text: string; hidden: string };
   sectioned?: boolean;
   view: 'list' | 'grid';
   backendQuery?: boolean;
@@ -38,7 +40,13 @@ export interface CollectionConfig {
   /** The card's primary verb, shown as a visible button beside the overflow.
    * `screenId` opens that screen with the row id; without it the verb reuses the
    * row's own tap action (the detail screen that owns the verb). */
-  primaryVerb?: { label: string; screenId?: string };
+  primaryVerb?: { label: string; screenId?: string;
+    /** A row field holding THIS row's verb label (Register, RSVP, Buy Tickets…); `label` stays the fallback copy. */
+    labelPath?: string;
+    /** A row boolean that hides the verb on rows that offer no action (an event with no registration). */
+    hiddenPath?: string };
+  /** The worker action that shares a row (`tier5.<service>.<name>` with `{ id }`): adds Share to the card's overflow menu. */
+  shareAction?: string;
   /** A TIME-BOUND entity (an event, a booking, a reservation): the boolean row field the
    *  DOMAIN sets once the record has finished — computed by the same rule as the row's own
    *  "Past" label, in the same place, so the two cannot disagree. A finished
@@ -73,7 +81,7 @@ export const COLLECTIONS: Record<string, CollectionConfig> = {
   himiBookingBookings: { rows: 'rows', title: 'title', subtitle: 'subtitle', metadata: ['status'], view: 'list', backendQuery: true,
     defaultFilter: 'value:Upcoming', searchPlaceholder: 'Search by booking ID', countNoun: ['booking', 'bookings'], filterValues: ['Upcoming', 'Past', 'Cancelled'],
     sortLabels: { default: 'Soonest', az: 'Oldest', za: 'Latest' } },
-  himiEvents: { rows: 'results', title: 'title', subtitle: 'dateLine', image: 'image', view: 'grid', backendQuery: true, defaultFilter: 'value:Upcoming', searchPlaceholder: 'Search events', countNoun: ['event', 'events'], filterValues: ['Upcoming', 'Past'], sortLabels: { default: 'Date', az: 'Title A–Z', za: 'Title Z–A' }, primaryVerb: { label: 'Register' }, endedWhen: 'isPast' },
+  himiEvents: { rows: 'results', title: 'title', subtitle: 'dateLine', image: 'image', dateBadge: { text: 'dateBadge', hidden: 'noDateBadge' }, gridColumns: 1, view: 'grid', backendQuery: true, defaultFilter: 'value:Upcoming', searchPlaceholder: 'Search events', countNoun: ['event', 'events'], filterValues: ['Upcoming', 'Past'], sortLabels: { default: 'Date', az: 'Title A–Z', za: 'Title Z–A' }, primaryVerb: { label: 'Register', labelPath: 'actionLabel', hiddenPath: 'noAction' }, shareAction: 'share', endedWhen: 'isPast' },
   himiBlogFeed: { rows: 'posts', title: 'title', subtitle: 'excerpt', image: 'image', filter: 'category', filterValuesFrom: 'categories', view: 'grid', narrowedBy: 'selectedCategoryId' },
   himiOwnerLiteProducts: { rows: 'products', title: 'name', subtitle: 'price', image: 'image', view: 'grid', backendQuery: true, countNoun: ['product', 'products'] },
   himiOwnerModules: { instanceInput: 'module', rows: 'rows', title: 'title', subtitle: 'subtitle', image: 'image', filter: 'statusLabel', view: 'list', paged: true, reviewAction: 'prepareRecord', reviewSelectedAction: 'prepareSelected' },
@@ -208,7 +216,15 @@ export function projectCollection(source: CollectionRow[], config: CollectionCon
       ...(config.endedWhen ? (() => {
         const ended = row[config.endedWhen] === true || (config.endedWhen === 'isPast' && row.statusLabel === 'Past');
         return { collectionEnded: ended, collectionNotEnded: !ended };
-      })() : {}) })),
+      })() : {}),
+      // A row restored from state saved by an older build has no badge flag. An unset hidden flag
+      // fails open and would paint an empty chip, so it reads as "no badge" until a refresh.
+      ...(config.dateBadge && typeof row[config.dateBadge.hidden] !== 'boolean'
+        ? { [config.dateBadge.text]: '', [config.dateBadge.hidden]: true } : {}),
+      // Same for a per-row verb: an unset hidden flag fails open and would show a verb with an unresolved
+      // label, so a row without the flag offers no action until a refresh establishes one.
+      ...(config.primaryVerb?.hiddenPath && typeof row[config.primaryVerb.hiddenPath] !== 'boolean'
+        ? { ...(config.primaryVerb.labelPath ? { [config.primaryVerb.labelPath]: '' } : {}), [config.primaryVerb.hiddenPath]: true } : {}) })),
     filters, loaded: rows.length,
   };
 }