@wix/himalaya-cli 0.1488.0 → 0.1490.0

package/templates/gym-fitness/himalaya.content.json

@@ -13,6 +13,9 @@
     "himi_addresses": {
       "displayName": "Addresses"
     },
+    "himi_agenda": {
+      "displayName": "Agenda"
+    },
     "himi_app_info": {
       "displayName": "App Info"
     },

package/templates/gym-fitness/tier5-src/_shared/branded-lite-hosted.ts

@@ -48,7 +48,7 @@ export const HOSTED_ALWAYS: readonly BrandedLiteVertical[] = ["members"];
 
 /** The screen each vertical's nav rows open, so a route to an uninstalled vertical can be answered. */
 export const VERTICAL_ROOT_SCREENS: Readonly<Record<string, readonly string[]>> = {
-  store: ["himi_shop"], bookings: ["himi_services"], restaurants: ["himi_menu", "himi_reserve"],
+  store: ["himi_shop"], bookings: ["himi_services", "himi_agenda"], restaurants: ["himi_menu", "himi_reserve"],
   programs: ["himi_programs"], plans: ["himi_plans"], feed: ["himi_feed"], members: ["himi_members"],
   forum: ["himi_forum"], coupons: ["himi_coupons"], notifications: ["himi_notifications"],
   loyalty: ["himi_loyalty"], reviews: ["himi_reviews"], portfolio: ["himi_portfolio"],
@@ -67,6 +67,7 @@ export const VERTICAL_ROOT_SCREENS: Readonly<Record<string, readonly string[]>>
 export const HOSTED_SCREEN_VERTICALS: Readonly<Record<string, readonly BrandedLiteVertical[]>> = {
   himi_address: ["restaurants", "store"],
   himi_addresses: ["restaurants", "store"],
+  himi_agenda: ["bookings"],
   himi_badge: ["badges"],
   himi_badges: ["badges"],
   himi_blog: ["blog"],

package/templates/gym-fitness/tier5-src/_shared/branded-load-state.ts

@@ -0,0 +1,106 @@
+// Load-state honesty for the branded-lite vertical workers.
+//
+// These workers used to answer every failed or empty query with representative SAMPLE
+// rows — discount codes, gift-card balances, invoices, reservations, inbox messages —
+// under a "Sample content" banner. On a customer build that is invented data presented
+// as the customer's own: a code that does not exist, a balance in the wrong currency, an
+// "Overdue" invoice, a booking labelled "tap to cancel". The banner did not make it
+// honest; the rows were still the first thing a visitor read.
+//
+// The rule now:
+//   • query FAILED     → status "error" with a customer sentence, a Retry, and — when
+//                        Wix refused an anonymous visitor (401) — a Sign in path instead;
+//   • query was EMPTY  → status "ready", no rows, the vertical's own empty sentence;
+//   • sample rows      → ONLY when the host explicitly asked for sample data (the web
+//                        preview's sample data mode, `__himiOwnerPreview: "sample"`).
+//                        Never on a device, never as a fallback.
+//
+// Every field here is flat and boolean-gated because descriptors can only
+// `hiddenWhen(<path>)` on a TRUE value: `notErrored` hides the error card, `noSignIn`
+// hides the sign-in CTA, `signInRequired` hides Retry when retrying cannot help.
+import { copyParam } from "./himi-copy.js";
+
+export interface LoadFlags {
+  status: "loading" | "ready" | "error";
+  /** The customer-facing failure sentence; "" unless status is "error". */
+  error: string;
+  signInRequired: boolean;
+  notErrored: boolean;
+  /** hiddenWhen gate for a loading skeleton. */
+  notLoading: boolean;
+  /** Loading or failed — gates content that has nothing to say in either. */
+  busy: boolean;
+  noSignIn: boolean;
+  isMock: boolean;
+  notMock: boolean;
+  notMockEmpty: boolean;
+  notMockUnavailable: boolean;
+}
+
+export const LOADING: LoadFlags = {
+  status: "loading", error: "", signInRequired: false, notErrored: true, notLoading: false, busy: true, noSignIn: true,
+  isMock: false, notMock: true, notMockEmpty: true, notMockUnavailable: true,
+};
+
+const READY: LoadFlags = { ...LOADING, status: "ready", notLoading: true, busy: false };
+
+/** Did the HOST ask for sample data? Only the web preview's sample mode does; a native
+ *  build, a visitor preview and a live owner preview never carry it. */
+export function samplesRequested(): boolean {
+  const input = (globalThis as { himalaya?: { input?: Record<string, unknown> } }).himalaya?.input;
+  return input?.__himiOwnerPreview === "sample";
+}
+
+/** Wix refused an ANONYMOUS visitor: signing in is the fix, not retrying. A 403 is not
+ *  this — it also answers "feature not installed" and a signed-in member without the
+ *  permission, where a Sign in button leads nowhere — so it stays a Retry-able failure. */
+export function needsSignIn(err: unknown): boolean {
+  const msg = String((err as { message?: unknown })?.message ?? err ?? "");
+  return /\b401\b|unauthori[sz]ed|unauthenticated/i.test(msg);
+}
+
+export interface LoadCopy<T> {
+  /** The copy namespace (`giftCards`, `coupons`, …) — keys resolve through copyParam. */
+  prefix: string;
+  /** Shown when the site genuinely has none. */
+  empty: string;
+  /** Shown when the query failed. */
+  error: string;
+  /** Shown when Wix refused the visitor (member-only data). */
+  signIn: string;
+  /** Sample rows for the explicit sample preview ONLY. */
+  sample: () => T[];
+}
+
+type Rows<K extends string, T> = { [P in K]: T[] } & { emptyText: string } & LoadFlags;
+
+/** A query answered. Rows win; an empty answer is a real empty state. */
+export function loaded<K extends string, T>(key: K, rows: T[], copy: LoadCopy<T>): Rows<K, T> {
+  if (rows.length) return { ...READY, [key]: rows, emptyText: "" } as Rows<K, T>;
+  if (samplesRequested()) return sampleRows(key, copy, "empty");
+  return { ...READY, [key]: [], emptyText: copyParam(`${copy.prefix}.emptyText`, copy.empty) } as Rows<K, T>;
+}
+
+/** A query threw. Never rows the customer did not create. */
+export function loadFailed<K extends string, T>(key: K, err: unknown, copy: LoadCopy<T>): Rows<K, T> {
+  if (samplesRequested()) return sampleRows(key, copy, "unavailable");
+  const signIn = needsSignIn(err);
+  return {
+    ...READY,
+    status: "error",
+    [key]: [],
+    emptyText: "",
+    error: signIn ? copyParam(`${copy.prefix}.signInText`, copy.signIn) : copyParam(`${copy.prefix}.errorText`, copy.error),
+    signInRequired: signIn,
+    notErrored: false,
+    busy: true,
+    noSignIn: !signIn,
+  } as Rows<K, T>;
+}
+
+function sampleRows<K extends string, T>(key: K, copy: LoadCopy<T>, reason: "empty" | "unavailable"): Rows<K, T> {
+  return {
+    ...READY, [key]: copy.sample(), emptyText: "",
+    isMock: true, notMock: false, notMockEmpty: reason !== "empty", notMockUnavailable: reason !== "unavailable",
+  } as Rows<K, T>;
+}

package/templates/gym-fitness/tier5-src/_shared/himi-bookings.ts

@@ -39,6 +39,20 @@ export function slotStartInstant(slot: { startDate?: string; timezone?: unknown
   return wall - (Number.isFinite(again) ? again : offset);
 }
 
+/** `himi_time` reads the next two weeks. A host's `start` past them (an Agenda session weeks
+ *  ahead) is read on its own — that session's local day only, never everything up to it — so it
+ *  can be preselected while each read stays bounded. `undefined` when the start is inside the two
+ *  weeks. */
+export function availabilityBeyond(now: Date, start = ""): { from: Date; until: Date } | undefined {
+  const end = now.getTime() + 14 * 86_400_000;
+  const at = start ? Date.parse(start) : NaN;
+  if (!Number.isFinite(at) || at < end) return undefined;
+  const d = new Date(at);
+  const dayStart = new Date(d.getFullYear(), d.getMonth(), d.getDate());
+  // Never back into the two weeks already read: a slot in both would be listed twice.
+  return { from: new Date(Math.max(dayStart.getTime(), end)), until: new Date(d.getFullYear(), d.getMonth(), d.getDate() + 1) };
+}
+
 /** The slot a host asked to open at (`himi_time` input `start`, an ISO 8601 instant): the id of the
  *  slot that starts at that same instant, or "" when none does (taken since, or out of the window).
  *  Compared as instants, so `…T16:30:00Z` finds a slot listed as `…T18:30:00+02:00`, or as a local

package/templates/gym-fitness/tier5-src/_shared/member-account-routes.ts

@@ -18,7 +18,8 @@ export const MEMBER_ACCOUNT_ROUTES_MIN_BINARY = "1.4.0";
 export const MEMBER_MEDIA_FIELD_MIN_BINARY = "1.5.0";
 export const MEMBER_PASSWORD_ACTIONS_MIN_BINARY = "1.5.0";
 
-function atLeast(version: string, floor: string): boolean {
+/** `version` (a HimalayaCore binary version, pre-release suffix ignored) is `floor` or later. */
+export function atLeast(version: string, floor: string): boolean {
   const parts = (v: string) => v.split("-")[0].split(".").map((p) => Number.parseInt(p, 10) || 0);
   const a = parts(version), b = parts(floor);
   for (let i = 0; i < Math.max(a.length, b.length); i++) {

package/templates/gym-fitness/tier5-src/himi-booking-time/index.ts

@@ -17,7 +17,7 @@ import { stashCopy, copyParam } from "../_shared/himi-copy.js";
 import { upsert as dbUpsert, remove as dbRemove, enqueue as dbEnqueue, type DbEntity } from "@himalaya/local-db";
 import { isBridgeUnavailable } from "../_shared/owner-load-error.js";
 import { emitHostEvent, hostEventInstant } from "../_shared/host-events.js";
-import { slotIdAt } from "../_shared/himi-bookings.js";
+import { availabilityBeyond, slotIdAt } from "../_shared/himi-bookings.js";
 import { wixMediaUrl, WIX_DETAIL_IMAGE } from "@himalaya/wix-media";
 
 // Offline-first (data-offline): booking a slot is WRITE-BEHIND against the
@@ -167,6 +167,15 @@ let pendingStart = (() => {
   const start = (globalThis as { himalaya?: { input?: { start?: unknown } } }).himalaya?.input?.start;
   return typeof start === "string" && Number.isFinite(Date.parse(start)) ? start : "";
 })();
+/** The exact session a host opened this screen at (`himalaya.input.sessionId`), when it names one:
+ *  two sessions of a class can start at the same instant, and `start` alone picks the first. */
+/** A host's `start` past the two-week window, kept for the life of this worker: a pick on that day
+ *  clears `pendingStart`, yet the reload after the guest sign-in step must still read it. */
+const farStart = pendingStart;
+let pendingSession = (() => {
+  const id = (globalThis as { himalaya?: { input?: { sessionId?: unknown } } }).himalaya?.input?.sessionId;
+  return typeof id === "string" ? id.trim() : "";
+})();
 
 function strOf(arg: unknown): string {
   if (typeof arg === "string") return arg;
@@ -197,12 +206,6 @@ function withTimeout<T>(promise: Promise<T>, ms: number): Promise<T> {
   });
 }
 
-function addDays(date: Date, days: number): Date {
-  const next = new Date(date);
-  next.setUTCDate(next.getUTCDate() + days);
-  return next;
-}
-
 function isoDate(date: Date): string {
   return date.toISOString();
 }
@@ -559,16 +562,21 @@ const svc = defineService<S, {
       let next = derive({ ...s, status: "loading", errored: false, message: "", successMessage: "" });
       next = await probeMember(next);
       try {
-        const [serviceRes, availability] = await Promise.all([
+        const now = new Date();
+        const beyond = availabilityBeyond(now, farStart);
+        const [serviceRes, availability, target] = await Promise.all([
           getService(s.id).catch(() => ({ service: undefined })),
-          queryServiceAvailability(s.id, isoDate(new Date()), isoDate(addDays(new Date(), 14))),
+          queryServiceAvailability(s.id, isoDate(now), isoDate(new Date(now.getTime() + WINDOW_DAYS * 86_400_000))),
+          // A host's start past the window (an Agenda session weeks out): its day alone, so it can
+          // be preselected. Its failure costs only that preselection.
+          beyond ? queryServiceAvailability(s.id, isoDate(beyond.from), isoDate(beyond.until)).catch(() => ({ availabilityEntries: [] })) : undefined,
         ]);
         slotsById = new Map();
         const rows: SlotRow[] = [];
         // Group by LOCAL calendar day, not by the formatted heading: two
         // distinct days can render the same text, and a UTC-derived key can
         // name a different day than the heading beside it.
-        for (const [index, entry] of (availability.availabilityEntries ?? [])
+        for (const [index, entry] of [...(availability.availabilityEntries ?? []), ...(target?.availabilityEntries ?? [])]
           .filter((candidate) => candidate.bookable !== false && candidate.slot?.startDate)
           .entries()) {
           const slot = entry.slot as WixBookingSlotFull;
@@ -595,7 +603,11 @@ const svc = defineService<S, {
         const chosen: S = selectionRevision !== revisionAtStart ? (svc.getState?.() ?? next) : next;
         // A host's `start` (deep entry): that slot preselected, or — taken since — its day.
         const wantedStart = pendingStart;
-        const startRow = wantedStart ? rows.find((r) => r.id === slotIdAt(slotsById, wantedStart)) : undefined;
+        // The named session (a slot row's id IS its session id), else the slot at that instant. A
+        // named session that is gone is "taken since" — never another session at the same time.
+        const startRow = !wantedStart ? undefined
+          : pendingSession ? rows.find((r) => r.id === pendingSession)
+          : rows.find((r) => r.id === slotIdAt(slotsById, wantedStart));
         // The requested day even with no time left on it: "taken since" opens there, nothing selected.
         const startDay = wantedStart ? days.find((d) => d.id === dayKey(wantedStart)) : undefined;
         const selectionAlive = !!startRow || slotsById.has(chosen.selectedSlotId);
@@ -638,6 +650,7 @@ const svc = defineService<S, {
       const day = chosenDay(arg);
       if (!day || !s.days.some((d) => d.id === day)) return derive(s);
       pendingStart = "";
+      pendingSession = "";
       return derive(withDay(s, day));
     },
     refreshMember: (s, arg) => { stashCopy(arg); return probeMember(s); },
@@ -649,6 +662,7 @@ const svc = defineService<S, {
       if (selected) {
         selectionRevision++;
         pendingStart = "";
+        pendingSession = "";
         if (s.isMember) clearPick();
         else rememberPick(s.id, slotId);
       }