@wix/himalaya-cli 0.1488.0 → 0.1489.0

package/templates/branded-lite/himalaya.content.json

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

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