@wix/himalaya-cli 0.1495.0 → 0.1497.0

package/templates/beauty-salon/tier5-src/_shared/iap-attendance-purchase.ts

@@ -0,0 +1,211 @@
+import { attendanceCheckoutRoute, availableTicketAttendanceOf, bookingAttendanceOf, classifyForApple, hostSessionFromGlobal, iapPriceFields, type BookingAttendance, type CatalogReference, type IapPollDirective, type TicketAttendance } from "@himalaya/iap";
+import { bookingOrders, createIapCommerce, eventTicketOrders, type IapOrderItem } from "@himalaya/iap-checkout";
+import { copyParam, copyTemplate } from "./himi-copy.js";
+import { createAttendanceForm, type AttendanceField } from "./iap-attendance-form.js";
+import { attendancePlatform } from "./iap-attendance.js";
+import { iapPriceCopy, iapPurchaseCopy } from "./iap-worker.js";
+
+export interface AttendancePurchaseFields {
+  iapBuyHidden: boolean;
+  iapBuyDisabled: boolean;
+  iapBuyLabel: string;
+  iapBusy: boolean;
+  iapPrice: string;
+  iapNote: string;
+  iapRetryHidden: boolean;
+  iapFormHidden: boolean;
+  iapFormError: string;
+  iapSignInHidden: boolean;
+  iapFields: AttendanceField[];
+  _poll?: IapPollDirective;
+}
+
+export const ATTENDANCE_INITIAL: AttendancePurchaseFields = {
+  iapBuyHidden: true, iapBuyDisabled: true, iapBuyLabel: "", iapBusy: false,
+  iapPrice: "", iapNote: "", iapRetryHidden: true, iapFormHidden: true, iapFormError: "", iapSignInHidden: true, iapFields: [],
+};
+export const ATTENDANCE_NOT_HYDRATED = [...Object.keys(ATTENDANCE_INITIAL), "_poll"] as (keyof AttendancePurchaseFields & string)[];
+
+export function createAttendancePurchase(options: { kind: "bookingsService" | "eventsTicket"; prefix: string; pollAction: string; onChange(): void }) {
+  const { prefix } = options;
+  let form = createAttendanceForm(prefix);
+  const submittedForms = new Map<string, ReturnType<typeof createAttendanceForm>>();
+  const session = hostSessionFromGlobal();
+  const commerce = createIapCommerce({ adapters: [options.kind === "bookingsService" ? bookingOrders : eventTicketOrders], onChange: options.onChange });
+  let generation = session.current().generation;
+  let reference: CatalogReference | undefined;
+  let metadata: BookingAttendance | TicketAttendance | undefined;
+  let platform = "unknown";
+  let started = false;
+  let inFlight = false;
+  let formError = "";
+  let sequence = 0;
+  let formRevision = 0;
+  const attempts = new Map<string, string>();
+  session.subscribe(() => { syncSession(); if (reference) options.onChange(); });
+
+  function syncSession(): void {
+    const next = session.current().generation;
+    if (next === generation) return;
+    generation = next;
+    form.clear();
+    submittedForms.clear();
+    formError = "";
+    attempts.clear();
+  }
+
+  async function refresh(): Promise<void> {
+    const next = await attendancePlatform(publishPlatform);
+    if (next !== "unknown" || platform === "unknown") platform = next;
+    await resume();
+  }
+
+  async function resume(): Promise<void> {
+    if (reference) await commerce.loadPrices([{ reference }]);
+    const first = !started;
+    started = true;
+    await (first ? commerce.start() : commerce.reconcile());
+  }
+
+  function publishPlatform(next: string): void {
+    if (next === "unknown" && platform !== "unknown") return;
+    platform = next;
+    void resume().then(options.onChange, options.onChange);
+  }
+
+  function show(): void {
+    void attendancePlatform(publishPlatform).then(publishPlatform, options.onChange);
+  }
+
+  async function booking(id: string, service: unknown): Promise<void> {
+    syncSession();
+    reference = { kind: options.kind, id };
+    metadata = bookingAttendanceOf(service);
+    selectForm(id, (next) => next.booking(service));
+    formRevision++;
+    formError = "";
+    await show();
+  }
+
+  async function ticket(id: string, event: unknown, available: unknown): Promise<void> {
+    syncSession();
+    reference = id ? { kind: options.kind, id } : undefined;
+    metadata = availableTicketAttendanceOf(event, available);
+    selectForm(id, (next) => next.event((event as { form?: unknown } | undefined)?.form));
+    formRevision++;
+    formError = "";
+    await show();
+  }
+
+  function selectForm(id: string, initialize: (next: ReturnType<typeof createAttendanceForm>) => void): void {
+    const key = `${options.kind}:${id}`;
+    const retained = submittedForms.get(key);
+    form = retained ?? createAttendanceForm(prefix);
+    if (!retained) initialize(form);
+  }
+
+  function fields(selected = true, publishPoll = true): AttendancePurchaseFields {
+    syncSession();
+    if (!reference || !metadata) return ATTENDANCE_INITIAL;
+    const currency = metadata.currency ?? "";
+    const classified = classifyForApple(metadata, currency);
+    const candidate = platform === "ios" && classified === "appleIap";
+    const price = iapPriceFields(commerce.pricing.view(reference), iapPriceCopy(prefix));
+    const copy = { ...iapPurchaseCopy(prefix), buy: copyParam(`${prefix}.appleBuyCta`, options.kind === "bookingsService" ? "Book with Apple" : "Buy ticket with Apple"), buyAnother: copyParam(`${prefix}.buyAnotherCta`, options.kind === "bookingsService" ? "Book again" : "Buy another ticket") };
+    const purchase = commerce.purchaseFields(reference, copy);
+    const apple = candidate || (platform === "ios" && classified !== "wixPayments" && purchase.appleRoute);
+    const enabled = attendanceCheckoutRoute(metadata, currency, platform) === "appleIap";
+    const poll = publishPoll ? commerce.pollDirective(options.pollAction) : undefined;
+    const state = commerce.state();
+    for (const [target, attempt] of attempts) {
+      const key = `${reference.kind}:${reference.id}#${encodeURIComponent(attempt)}`;
+      if ((state.phase === "accessReady" && state.item === key) || state.payments.some((p) => p.item === key && p.access === "granted")) attempts.delete(target);
+    }
+    const formKey = `${reference.kind}:${reference.id}`;
+    if (![...attempts.keys()].some((target) => target.startsWith(`${formKey}:`))) submittedForms.delete(formKey);
+    const own = state.item?.startsWith(`${reference.kind}:${reference.id}#`);
+    const completed = state.phase === "accessReady" && own;
+    const member = session.current().kind === "member";
+    let note = "";
+    if (apple && !enabled) note = copy.unavailable;
+    else if (apple && !member) note = copy.signInRequired;
+    else if (apple && purchase.buyNote) note = purchase.buyNote;
+    else if (apple && !form.supported()) note = copyParam(`${prefix}.formUnavailableText`, "This registration form is not supported yet.");
+    else if (apple && completed) note = copyParam(`${prefix}.purchaseCompleteText`, options.kind === "bookingsService" ? "Your booking is confirmed." : "Your ticket is confirmed.");
+    else if (apple && own && state.phase === "cancelled") note = copyParam(`${prefix}.purchaseCancelledText`, "Purchase cancelled. Your place is not confirmed.");
+    return {
+      iapBuyHidden: !apple, iapBuyDisabled: !enabled || !selected || !member || !form.supported() || purchase.buyDisabled || inFlight,
+      iapBuyLabel: purchase.buyLabel || copy.buy, iapBusy: purchase.buyBusy || inFlight,
+      iapPrice: apple ? price.priceText : "", iapRetryHidden: !apple || (price.hidePriceRetry && commerce.scopeComplete()),
+      iapNote: note,
+      iapFormHidden: !apple || !selected || !form.supported(), iapFormError: formError,
+      iapSignInHidden: !apple || member || options.kind === "bookingsService",
+      iapFields: form.rows().map((f, index, rows) => ({ ...f,
+        id: `${generation}:${formRevision}:${f.id}`, fieldId: f.id,
+        errorHidden: !f.error,
+        options: f.options.map((o) => ({ ...o, fieldId: f.id, displayLabel: (f.kind === "multiple" ? f.selectedIds.includes(o.id) : f.value === o.id) ? `${o.label} ✓` : o.label })),
+        label: f.required ? `${f.label} *` : f.label,
+        inputLabel: copyTemplate(`${prefix}.fieldAccessibilityLabel`, "{section}: {field}", { section: f.id.startsWith("buyer:") ? copyParam(`${prefix}.buyerDetailsLabel`, "Buyer details") : copyParam(`${prefix}.guestDetailsLabel`, "Ticket holder details"), field: f.label }),
+        sectionLabel: index === 0 ? copyParam(`${prefix}.buyerDetailsLabel`, "Buyer details") : f.id.startsWith("guest:") && rows[index - 1].id.startsWith("buyer:") ? copyParam(`${prefix}.guestDetailsLabel`, "Ticket holder details") : "",
+      })), ...(poll ? { _poll: poll } : {}),
+    };
+  }
+
+  async function buy(selection: { key: string; slot?: Record<string, unknown>; eventId?: string }): Promise<void> {
+    syncSession();
+    if (!reference || !metadata || fields(true, false).iapBuyDisabled || inFlight) return;
+    if (options.kind === "eventsTicket" && reference.id !== selection.key) return;
+    if (!form.validate()) { formError = copyParam(`${prefix}.formRequiredText`, "Complete the required details before purchasing."); return; }
+    if (session.current().kind !== "member") { formError = iapPurchaseCopy(prefix).signInRequired; return; }
+    const currentGeneration = generation;
+    const ref = reference;
+    submittedForms.set(`${ref.kind}:${ref.id}`, form);
+    const target = `${ref.kind}:${ref.id}:${selection.key}`;
+    let attemptId = attempts.get(target);
+    const state = commerce.state();
+    const attemptKey = attemptId ? `${ref.kind}:${ref.id}#${encodeURIComponent(attemptId)}` : "";
+    const completed = attemptId && ((state.phase === "accessReady" && state.item === attemptKey) || state.payments.some((p) => p.item === attemptKey && p.access === "granted"));
+    if (!attemptId || completed) { attemptId = `${Date.now().toString(36)}-${++sequence}-${Math.random().toString(36).slice(2)}`; attempts.set(target, attemptId); }
+    const item: IapOrderItem = { reference: ref, attemptId, quantity: 1, attendance: {
+      amount: metadata.amount!, currency: metadata.currency!,
+      ...(options.kind === "bookingsService" ? { booking: { slot: selection.slot ?? {}, contactDetails: form.buyer() } } : { ticket: { eventId: selection.eventId ?? "", ...form.ticket(ref.id) } }),
+    } };
+    inFlight = true;
+    formError = "";
+    options.onChange();
+    try {
+      await commerce.buy(item);
+      const after = commerce.state();
+      if (after.phase === "accessReady" && after.item === `${ref.kind}:${ref.id}#${encodeURIComponent(attemptId)}`) attempts.delete(target);
+    }
+    finally { inFlight = false; syncSession(); if (generation !== currentGeneration) form.clear(); options.onChange(); }
+  }
+
+  function change(arg: unknown): void {
+    syncSession();
+    const state = commerce.state();
+    if (reference) {
+      for (const [target, attempt] of attempts) {
+        const item = `${reference.kind}:${reference.id}#${encodeURIComponent(attempt)}`;
+        const canCorrect = state.phase === "cancelled" || (state.phase === "refused" && (state.failure === "orderRefused" || state.failure === "productChanged"));
+        if (canCorrect && state.item === item) { attempts.delete(target); submittedForms.delete(`${reference.kind}:${reference.id}`); }
+      }
+      const referencePrefix = `${reference.kind}:${reference.id}:`;
+      if (inFlight || [...attempts.keys()].some((target) => target.startsWith(referencePrefix))) {
+        formError = copyParam(`${prefix}.detailsLockedText`, "Finish the current purchase before changing registration details.");
+        return;
+      }
+    }
+    form.change(arg);
+    formError = "";
+  }
+
+  return {
+    booking, ticket, fields, buy,
+    usesRegularPlatform: () => platform === "android" || platform === "web",
+    invalidate: () => { reference = undefined; metadata = undefined; options.onChange(); },
+    change,
+    refresh,
+    poll: async () => { syncSession(); await commerce.poll(); },
+  };
+}

package/templates/beauty-salon/tier5-src/_shared/iap-attendance.ts

@@ -0,0 +1,38 @@
+import { get as appInfo } from "@himalaya/app-info";
+import { attendanceCheckoutRoute, bookingAttendanceOf, ticketAttendanceOf } from "@himalaya/iap";
+
+let knownPlatform: string | undefined;
+
+export function attendancePlatform(onResolved?: (platform: string) => void): Promise<string> {
+  if (knownPlatform) return Promise.resolve(knownPlatform);
+  const info = appInfo().then((value) => value.platform, () => "unknown").then((platform) => {
+    if (platform !== "unknown") knownPlatform = platform;
+    return platform;
+  });
+  const host = globalThis as { setTimeout?: (fn: () => void, ms: number) => unknown; clearTimeout?: (timer: unknown) => void };
+  if (!host.setTimeout) {
+    void info.then((platform) => onResolved?.(platform));
+    return Promise.resolve("unknown");
+  }
+  return new Promise((resolve) => {
+    let timedOut = false;
+    const timer = host.setTimeout!(() => { timedOut = true; resolve("unknown"); }, 1500);
+    void info.then((platform) => { host.clearTimeout?.(timer); resolve(platform); if (timedOut) onResolved?.(platform); });
+  });
+}
+
+export async function mayUseRegularBookingCheckout(service: unknown): Promise<boolean> {
+  const metadata = bookingAttendanceOf(service);
+  if (metadata.priceType === "NO_FEE" || isZero(metadata.amount)) return true;
+  return attendanceCheckoutRoute(metadata, metadata.currency ?? "", await attendancePlatform()) === "regular";
+}
+
+export async function mayUseRegularTicketCheckout(event: unknown, ticket: { free?: boolean; price?: { amount?: string; currency?: string }; saleStatus?: string } | undefined): Promise<boolean> {
+  if (ticket?.free === true || isZero(ticket?.price?.amount)) return true;
+  const metadata = ticketAttendanceOf(event, { hidden: false, saleStatus: ticket?.saleStatus });
+  return attendanceCheckoutRoute(metadata, ticket?.price?.currency ?? "", await attendancePlatform()) === "regular";
+}
+
+function isZero(value: unknown): boolean {
+  return typeof value === "string" && /^0+(?:\.0+)?$/.test(value);
+}

package/templates/beauty-salon/tier5-src/himi-booking-time/index.ts

@@ -19,6 +19,9 @@ import { isBridgeUnavailable } from "../_shared/owner-load-error.js";
 import { emitHostEvent, hostEventInstant } from "../_shared/host-events.js";
 import { availabilityBeyond, slotIdAt } from "../_shared/himi-bookings.js";
 import { wixMediaUrl, WIX_DETAIL_IMAGE } from "@himalaya/wix-media";
+import { mayUseRegularBookingCheckout } 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";
 
 // Offline-first (data-offline): booking a slot is WRITE-BEHIND against the
 // `member_bookings` entity (the same rows the My Bookings worker reads). The
@@ -53,7 +56,7 @@ interface SlotRow {
   notSelected: boolean;
 }
 
-interface S {
+interface S extends AttendancePurchaseFields {
   status: "loading" | "ready";
   id: string;
   serviceName: string;
@@ -132,6 +135,10 @@ interface DayOption {
 }
 
 let slotsById = new Map<string, WixBookingSlotFull>();
+let regularCheckoutAllowed = false;
+let regularServicePrice = "";
+let lastReady: S | undefined;
+const applePurchase = createAttendancePurchase({ kind: "bookingsService", prefix: "time", pollAction: "himiBookingTime.iapPoll", onChange: () => { void svc.iapPublish(); } });
 /** Every slot row in the window, across all days. Kept out of worker state so
  *  the state the host receives holds one day's rows, not the whole window. */
 let allRows: SlotRow[] = [];
@@ -326,18 +333,24 @@ function withDay(s: S, day: string): S {
 }
 
 function derive(s: S): S {
+  const regular = regularCheckoutAllowed || applePurchase.usesRegularPlatform();
   // `hasSlots` is the WHOLE window (it drives the screen-level empty state); the
   // selected day having none is a per-day line, not an empty screen.
   const hasSlots = s.days.some((d) => d.hasSlots) || s.slots.length > 0;
   const hasDaySlots = s.slots.length > 0;
   const hasSelected = !!s.selectedSlotId;
   const hasSuccess = !!s.successMessage;
-  const canBook = s.isMember && hasSelected && !s.bookingInFlight && !hasSuccess;
-  const showChoosePrompt = s.isMember && hasSlots && !hasSelected && !s.bookingInFlight && !hasSuccess;
+  const canBook = regular && s.isMember && hasSelected && !s.bookingInFlight && !hasSuccess;
+  const showChoosePrompt = regular && s.isMember && hasSlots && !hasSelected && !s.bookingInFlight && !hasSuccess;
   const isRegistering = !!s.isRegistering;
-  return {
+  const next: S = {
     ...s,
+    _poll: undefined,
+    servicePrice: regular ? regularServicePrice : "",
+    serviceLine: s.status === "ready" ? [s.serviceDuration, regular ? regularServicePrice : "", copyParam("time.availabilityWindow", "Available in the next 14 days")].filter(Boolean).join(" · ") : s.serviceLine,
+    message: regular && !regularCheckoutAllowed && s.message === copyParam("time.purchaseUnavailable", "Purchasing is temporarily unavailable.") ? "" : s.message,
     hasSlots,
+    ...applePurchase.fields(hasSelected),
     hasSelected,
     noSelected: !hasSelected,
     hideSignIn: s.isMember || !hasSelected,
@@ -375,6 +388,8 @@ function derive(s: S): S {
       ? copyParam("time.authBodyRegister", "Create a member account, then book the selected time on this screen.")
       : copyParam("time.authBody", "You can browse times as a visitor. Booking is saved to a member account."),
   };
+  if (next.status === "ready") lastReady = next;
+  return next;
 }
 
 async function probeMember(s: S): Promise<S> {
@@ -499,8 +514,15 @@ const svc = defineService<S, {
   signIn: (s: S) => Promise<S>;
   register: (s: S) => Promise<S>;
   bookSelected: (s: S) => Promise<S>;
+  buyApple: (s: S) => Promise<S>;
+  setIapField: (s: S, arg?: unknown) => S;
+  iapPublish: (s: S) => S;
+  iapRefresh: (s: S) => Promise<S>;
+  iapPoll: (s: S) => Promise<S>;
 }>("himiBookingTime", {
+  notHydrated: [...ATTENDANCE_NOT_HYDRATED, "email", "password", "firstName", "lastName", "isMember", "canBook", "cannotBook"],
   state: derive({
+    ...ATTENDANCE_INITIAL,
     status: "loading",
     id,
     serviceName: "Choose a time",
@@ -555,6 +577,16 @@ const svc = defineService<S, {
     bookingsScreenId: "himi_bookings",
   }),
   actions: {
+    iapPublish: (s) => derive(lastReady ?? s),
+    iapRefresh: async (): Promise<S> => { await applePurchase.refresh(); return derive(svc.getState()); },
+    iapPoll: async (): Promise<S> => { await applePurchase.poll(); return derive(svc.getState()); },
+    setIapField: (s, arg) => { applePurchase.change(arg); return derive(s); },
+    buyApple: async (s: S): Promise<S> => {
+      const slot = slotsById.get(s.selectedSlotId);
+      if (!slot || !s.isMember) return derive(s);
+      await applePurchase.buy({ key: s.selectedSlotId, slot: slot as unknown as Record<string, unknown> });
+      return derive(svc.getState());
+    },
     load: async (s, arg): Promise<S> => {
       const revisionAtStart = selectionRevision;
       stashCopy(arg);
@@ -598,6 +630,10 @@ const svc = defineService<S, {
         }
         allRows = rows;
         const days = daysOf(rows);
+        const header = serviceHeaderFields(serviceRes.service);
+        regularServicePrice = header.price;
+        regularCheckoutAllowed = await mayUseRegularBookingCheckout(serviceRes.service);
+        await applePurchase.booking(s.id, serviceRes.service);
         // A reload runs in the background when the screen shows again. A time the customer
         // picked while it ran wins over the selection this load started from.
         const chosen: S = selectionRevision !== revisionAtStart ? (svc.getState?.() ?? next) : next;
@@ -617,7 +653,6 @@ const svc = defineService<S, {
         // otherwise open on the first day that has any.
         const keep = days.find((d) => d.id === chosen.selectedDay && d.hasSlots);
         const initialDay = startRow?.dayKey ?? startDay?.id ?? picked?.dayKey ?? keep?.id ?? days.find((d) => d.hasSlots)?.id ?? days[0]?.id ?? "";
-        const header = serviceHeaderFields(serviceRes.service);
         return derive(withDay({
           ...next,
           days,
@@ -628,13 +663,14 @@ const svc = defineService<S, {
           status: "ready",
           errored: false,
           serviceName: serviceRes.service?.name || copyParam("time.serviceNameFallback", "Choose a time"),
-          serviceLine: [header.duration, header.price, copyParam("time.availabilityWindow", "Available in the next 14 days")].filter(Boolean).join(" · "),
+          serviceLine: [header.duration, regularCheckoutAllowed ? header.price : "", copyParam("time.availabilityWindow", "Available in the next 14 days")].filter(Boolean).join(" · "),
           serviceImage: header.image,
           hasServiceImage: !!header.image,
           noServiceImage: !header.image,
-          servicePrice: header.price,
+          servicePrice: regularCheckoutAllowed ? header.price : "",
           serviceDuration: header.duration,
           serviceIsPaid: header.paid,
+          message: regularCheckoutAllowed || !applePurchase.fields(true, false).iapBuyHidden ? "" : copyParam("time.purchaseUnavailable", "Purchasing is temporarily unavailable."),
         }, initialDay));
       } catch {
         slotsById = new Map();
@@ -727,6 +763,14 @@ const svc = defineService<S, {
       if (!s.selectedSlotId) return derive({ ...s, message: copyParam("time.bookNeedsSlot", "Choose one time first.") });
       const slot = slotsById.get(s.selectedSlotId);
       if (!slot) return derive({ ...s, message: copyParam("time.bookSlotGone", "That time is no longer available. Try again.") });
+      try {
+        const current = await getService(s.id);
+        regularCheckoutAllowed = await mayUseRegularBookingCheckout(current.service);
+        if (serviceHeaderFields(current.service).paid !== s.serviceIsPaid) return derive({ ...s, message: copyParam("time.purchaseUnavailable", "Purchasing is temporarily unavailable.") });
+      } catch {
+        if (s.serviceIsPaid) return derive({ ...s, message: copyParam("time.purchaseUnavailable", "Purchasing is temporarily unavailable.") });
+      }
+      if (!regularCheckoutAllowed) return derive({ ...s, message: copyParam("time.purchaseUnavailable", "Purchasing is temporarily unavailable.") });
       // A confirmed booking is reported to the app hosting this screen (an embed's `onAction`), so a
       // host chat can say so and refresh what it shows. Dropped where nothing hosts the screen.
       // The booking's own instants carry an offset; a slot's may be LOCAL to its timezone, which
@@ -867,5 +911,6 @@ const svc = defineService<S, {
     },
   },
 });
+resetUnhydratedKeysOnOlderRuntime(svc, { ...svc.getState(), ...ATTENDANCE_INITIAL, email: "", password: "", firstName: "", lastName: "", isMember: false, canBook: false, cannotBook: true }, [...ATTENDANCE_NOT_HYDRATED, "email", "password", "firstName", "lastName", "isMember", "canBook", "cannotBook"]);
 svc.load();
 export { svc };