@wix/himalaya-cli 0.1497.0 → 0.1499.0

package/templates/events-meetups/tier5-src/_shared/iap-presentation.ts

@@ -11,46 +11,189 @@ export function withIapPresentation<S extends object>(options: {
   onCreate?(commerce: IapCommerce): void;
   onContent?(state: S): void;
   items(state: S): IapCatalogItem[];
-  present(state: S, price: (id: string, commercePrice?: string) => string, allowed: (id: string) => boolean): S;
+  present(state: S, price: (id: string, commercePrice?: string) => string, allowed: (id: string) => boolean, appleIapOrResolving: (id: string) => boolean): S;
   contentActions: string[];
+  /** Defaults to load/refresh/retry; mutations can explicitly request fresh mapping. */
+  forcePriceRefreshActions?: string[];
+  concurrentPublishActions?: string[];
+  /** Override the commerce factory in focused worker tests. */
+  commerceFactory?: typeof createIapCommerce;
   transientKeys: (keyof S & string)[];
   prefix: string;
 }): typeof defineService {
   return ((name: string, definition: ServiceDefinition<S>) => {
-    const commerce = createIapCommerce({ adapters: options.adapters, onChange: () => { void service.iapPublish(); } });
+    let queuePublish = () => {};
+    const commerce = (options.commerceFactory ?? createIapCommerce)({ adapters: options.adapters, onChange: () => queuePublish() });
     options.onCreate?.(commerce);
     let items: IapCatalogItem[] = [];
+    let loadedItemsKey = "";
+    const settledViews = new Map<string, { commerceDisplayPrice?: string; view: ReturnType<IapCommerce["pricing"]["view"]> }>();
+    const forcePriceRefreshActions = new Set(options.forcePriceRefreshActions ?? options.contentActions.filter(action => ["load", "refresh", "retry"].includes(action)));
     let contentVersion = 0;
-    const project = (state: S): S => {
+    let actionVersion = 0;
+    let activeActions = 0;
+    let activeConcurrentPublishActions = 0;
+    let actionWaiters: Array<() => void> = [];
+    let publishQueued = false;
+    // pollDirective() arms its interval as a side effect. Keep a directive from a
+    // projection that loses a commit race so the retry can still publish it.
+    let uncommittedPollDirective: ReturnType<IapCommerce["pollDirective"]>;
+    let uncommittedPollVersion = 0;
+    // The committed state, read when a publish runs. Assigned once the service exists, so the
+    // service's own initializer never refers to it.
+    let committed: () => S = () => definition.state;
+    queuePublish = () => {
+      if (publishQueued) return;
+      publishQueued = true;
+      // Tier-5 workers have no timer globals. A microtask is enough here: if the
+      // action that caused the price update is still in flight, iapPublish's
+      // action-version check queues another publish after that action commits.
+      const publish = () => {
+        publishQueued = false;
+        void service.iapPublish();
+      };
+      void Promise.resolve().then(publish);
+    };
+    const project = (state: S, retainedPoll?: ReturnType<IapCommerce["pollDirective"]>): S => {
+      const presentationView = (id: string, commercePrice?: string) => {
+        const item = items.find(item => item.reference.id === id);
+        const reference = item?.reference ?? { kind: "storesProduct", id };
+        const key = `${reference.kind}:${reference.id}`;
+        const current = commerce.pricing.view(reference);
+        const cached = settledViews.get(key);
+        const displayPrice = commercePrice ?? item?.commerceDisplayPrice;
+        if (current.route === "resolving" && cached && cached.commerceDisplayPrice === displayPrice) return cached.view;
+        if (current.route !== "resolving" && item) settledViews.set(key, { commerceDisplayPrice: item.commerceDisplayPrice, view: current });
+        return current;
+      };
       const price = (id: string, commercePrice?: string) => {
         const item = items.find(item => item.reference.id === id);
         if (!item) return "";
-        const view = commerce.pricing.view(item.reference);
+        const view = presentationView(id, commercePrice);
+        if (view.route === "resolving") return iapPriceCopy(options.prefix).loading;
         return view.route === "disabled" || view.route === "regular" ? commercePrice ?? item.commerceDisplayPrice ?? "" : iapPriceFields(view, iapPriceCopy(options.prefix)).priceText;
       };
       const allowed = (id: string) => commerce.pricing.checkoutGuard({ kind: "storesProduct", id }).allowed;
-      const poll = commerce.pollDirective(`${name}.iapPoll`);
-      return { ...options.present(state, price, allowed), ...(poll ? { _poll: poll } : {}) };
+      const appleIapOrResolving = (id: string) => ["appleIap", "resolving", "unavailable"].includes(presentationView(id).route);
+      // Re-evaluate the cadence first. A checkout can enter/leave due work while a prior
+      // projection is waiting to retry; a fresh directive supersedes the retained one.
+      const poll = commerce.pollDirective(`${name}.iapPoll`) ?? retainedPoll;
+      return { ...options.present(state, price, allowed, appleIapOrResolving), ...(poll ? { _poll: poll } : {}) };
     };
-    const actions = Object.fromEntries(Object.entries(definition.actions ?? {}).map(([action, reduce]) => [action, async (state: S, ...args: never[]) => {
+    const mergeConcurrent = (before: S, next: S, current: S): S => {
+      if (current === before) return next;
+      const merged = { ...current } as Record<string, unknown>;
+      const previous = before as Record<string, unknown>;
+      const changed = next as Record<string, unknown>;
+      for (const key of new Set([...Object.keys(previous), ...Object.keys(changed)])) {
+        if (JSON.stringify(previous[key]) === JSON.stringify(changed[key])) continue;
+        if (Object.prototype.hasOwnProperty.call(changed, key)) merged[key] = changed[key];
+        else delete merged[key];
+      }
+      return merged as S;
+    };
+    const actions = Object.fromEntries(Object.entries(definition.actions ?? {}).map(([action, reduce]) => [action, (state: S, ...args: never[]) => {
+      actionVersion++;
+      activeActions++;
+      const concurrentPublish = options.concurrentPublishActions?.includes(action) ?? false;
+      if (concurrentPublish) activeConcurrentPublishActions++;
       const content = options.contentActions.includes(action);
       const version = action === "load" ? ++contentVersion : contentVersion;
-      const next = await reduce(state, ...args);
-      if (!next || (content && version !== contentVersion)) return undefined;
-      if (content) {
-        options.onContent?.(next);
-        items = options.items(next);
-        void commerce.loadPrices(items);
+      const presentResult = (next: S | undefined) => {
+        // scopeLanded is the completion of the active load, not a stale load result. It
+        // must publish even if another overlapping onAppear load advanced contentVersion.
+        if (!next || (content && action !== "scopeLanded" && version !== contentVersion)) return undefined;
+        if (content) {
+          options.onContent?.(next);
+          const nextItems = options.items(next);
+          // This is an order-independent identity key, not display text. Default
+          // string ordering is deterministic on every worker engine, including QuickJS.
+          const nextItemsKey = JSON.stringify(nextItems.map(item => JSON.stringify([item.reference.kind, item.reference.id, item.commerceDisplayPrice]))
+            .sort());
+          items = nextItems;
+          const forcePriceRefresh = forcePriceRefreshActions.has(action);
+          if (forcePriceRefresh) settledViews.clear();
+          if (nextItemsKey !== loadedItemsKey || forcePriceRefresh) {
+            loadedItemsKey = nextItemsKey;
+            void commerce.loadPrices(items);
+          }
+        }
+        // Checkout preserves prices published while it ran.
+        return project(concurrentPublish ? mergeConcurrent(state, next, committed()) : next);
+      };
+      const finished = () => {
+        activeActions--;
+        if (concurrentPublish) activeConcurrentPublishActions--;
+        const waiters = actionWaiters;
+        actionWaiters = [];
+        for (const resolve of waiters) resolve();
+      };
+      try {
+        const next = reduce(state, ...args);
+        // Keep synchronous sidecars synchronous. Adding an await lets their old
+        // catalog snapshot commit after a newer asynchronous refresh.
+        if (content || (next && typeof (next as Promise<S | undefined>).then === "function")) {
+          return (async () => {
+            try { return presentResult(await next); }
+            finally { finished(); }
+          })();
+        }
+        const result = presentResult(next as S | undefined);
+        finished();
+        return result;
+      } catch (error) {
+        finished();
+        throw error;
       }
-      return project(next);
     }]));
     const service = (options.register ?? defineService)(name, {
       // The collection's shown page goes with the rows and chrome it copies: kept out of the restore with them.
       ...definition, notHydrated: [...(definition.notHydrated ?? []), ...options.transientKeys,
         ...((options.transientKeys as string[]).includes('collection') ? ['collectionShown' as keyof S & string] : [])],
-      actions: { ...actions, iapPublish: project, iapPoll: async () => { await commerce.poll(); return undefined; },
+      // Prices land on their own clock, and a commit replaces the whole state — so a publish
+      // can carry a snapshot that an in-flight commit (a page that just landed, a tap) has
+      // since replaced. Project the state as it is now, and publish only when the prices
+      // actually change it: with no App Store mapping, or prices already shown, there is
+      // nothing to publish and nothing to overwrite.
+      actions: { ...actions, iapPublish: async () => {
+        // Checkout actions publish their busy phase while running. Every other action
+        // finishes before we take a projection, so it cannot erase a reducer's result.
+        for (;;) {
+          if (activeActions > activeConcurrentPublishActions) await new Promise<void>(resolve => actionWaiters.push(resolve));
+          await Promise.resolve();
+          const version = actionVersion;
+          await Promise.resolve();
+          if (activeActions <= activeConcurrentPublishActions && version === actionVersion) break;
+        }
+        const current = committed();
+        // The runtime commits an action's result just after this wrapper returns. If a
+        // scope action lands while prices are being projected, publishing this snapshot
+        // would put the older scope back on top. Drop it and retry against the commit.
+        const retainedPollVersion = uncommittedPollVersion;
+        const retainedPoll = uncommittedPollDirective;
+        const next: S & { _poll?: unknown } = project(current, retainedPoll);
+        await Promise.resolve();
+        if (committed() !== current) {
+          // Overlapping retries can race too: a projection with no new directive must
+          // not erase one another already retained after pollDirective() armed itself.
+          if (next._poll) {
+            uncommittedPollDirective = next._poll as ReturnType<IapCommerce["pollDirective"]>;
+            uncommittedPollVersion++;
+          }
+          queuePublish();
+          return undefined;
+        }
+        // Another concurrent projection may have retained a newer directive since this
+        // snapshot. Clear only the exact retained generation this successful commit used.
+        if (next._poll && retainedPollVersion === uncommittedPollVersion && retainedPoll === uncommittedPollDirective) {
+          uncommittedPollDirective = undefined;
+          uncommittedPollVersion++;
+        }
+        return !next._poll && JSON.stringify(next) === JSON.stringify(current) ? undefined : next;
+      }, iapPoll: async () => { await commerce.poll(); return undefined; },
         iapRefresh: async () => { await commerce.loadPrices(items); return undefined; } },
     });
+    committed = () => (service as unknown as { getState(): S }).getState();
     resetUnhydratedKeysOnOlderRuntime(service, definition.state, options.transientKeys);
     return service;
   }) as unknown as typeof defineService;

package/templates/events-meetups/tier5-src/himi-branded-lite-home/index.ts

@@ -2,6 +2,7 @@ import { fetchMemberBookings, type MemberBookingRow } from "../_shared/member-bo
 import { hostSiteFromInput, hostedExploreCards, hostedHiddenFlags, type HostedExploreCard } from "../_shared/branded-lite-hosted.js";
 import { memberAccess, assertMemberAccess } from "../_shared/member-access.js";
 import { defineService as registerHome } from "../_shared/home-service.js";
+import { navigate } from "@himalaya/state";
 import { withIapPresentation } from "../_shared/iap-presentation.js";
 import { queryServices, type WixService } from "@himalaya/wix-bookings";
 import { getPost, queryPosts, type WixPost } from "@himalaya/wix-blog";
@@ -20,6 +21,7 @@ import { parseWeeklyGoal, weeklyGoalProgress, weeklySessionsFromPages } from "..
 import { isBridgeUnavailable } from "../_shared/owner-load-error.js";
 import { formatDateMedium } from "../_shared/engine-intl.js";
 import { readSavedProducts, type SavedProduct } from "../_shared/himi-store-saved.js";
+import { loadStoreCategories, type StoreCategoryCard } from "../_shared/himi-store-categories.js";
 import { readSavedIds } from "../_shared/himi-blog-saved.js";
 import { wixMediaUrl } from "@himalaya/wix-media";
 import { isWixVideoWebRefusal, listLatestVideos, videoCard, type WixVideoCard } from "@himalaya/wix-video";
@@ -270,6 +272,9 @@ interface State {
   noHeroImage: boolean;
   hasFeaturedProducts: boolean;
   noFeaturedProducts: boolean;
+  /** The store's categories for the "Shop by category" rail; each opens Shop on that chip. */
+  homeCategories: StoreCategoryCard[];
+  noHomeCategories: boolean;
   /** Schedule-only trainingFirst fields (design §4.1). They remain empty until
    *  a dated availability source can back them; collapse gates hide them. */
   todaysClasses: ClassEntry[];
@@ -857,6 +862,7 @@ function derive(state: State): State {
     noHeroImage: !hasHeroImage,
     hasFeaturedProducts: state.featuredProducts.length > 0,
     noFeaturedProducts: state.featuredProducts.length === 0,
+    noHomeCategories: (state.homeCategories ?? []).length === 0,
     noSavedProducts: state.savedProducts.length === 0,
     noSavedPosts: state.savedPosts.length === 0,
     noSavedContent: state.savedProducts.length === 0 && state.savedPosts.length === 0,
@@ -950,6 +956,8 @@ function baseState(): State {
     noHeroImage: true,
     hasFeaturedProducts: false,
     noFeaturedProducts: true,
+    homeCategories: [],
+    noHomeCategories: true,
     todaysClasses: [],
     noTodaysClasses: true,
     coachAvatars: [],
@@ -998,6 +1006,7 @@ let refreshGen = 0;
 /** Last successful featured list — catch paths read this when the action's
  *  `state` snapshot was captured before a racing refresh painted products. */
 let lastFeaturedProducts: ProductFeature[] = [];
+let lastHomeCategories: StoreCategoryCard[] = [];
 
 async function refreshPublic(state: State, arg?: unknown): Promise<State | undefined> {
   // Absorb the descriptor's copy-pack overrides (if any) before any string is
@@ -1034,6 +1043,21 @@ async function refreshPublic(state: State, arg?: unknown): Promise<State | undef
       effectiveLayout: resolveEffectiveLayout(arg, 0),
     });
   }
+  // Categories ride beside the products; a failed read only hides their rail. Started
+  // outside the try, and merged as a separate action so a slow categories endpoint cannot
+  // hold the primary products rail behind it. Offline on a cold boot the module copy is
+  // still empty: fall back to the rail the state restored.
+  let categoriesResolved = false;
+  let resolvedCategories: StoreCategoryCard[] = [];
+  const categoriesRead = loadStoreCategories().catch(() => (lastHomeCategories.length ? lastHomeCategories : state.homeCategories ?? []));
+  void categoriesRead.then((homeCategories) => {
+    categoriesResolved = true;
+    resolvedCategories = homeCategories;
+    if (gen === refreshGen) {
+      lastHomeCategories = homeCategories;
+      void svc.categoriesLoaded({ generation: gen, categories: homeCategories });
+    }
+  });
   try {
     const response = await queryStoreProducts(50);
     if (gen !== refreshGen) return undefined;
@@ -1051,6 +1075,7 @@ async function refreshPublic(state: State, arg?: unknown): Promise<State | undef
       welcome: welcome(),
       refreshedAt: new Date().toISOString(),
       featuredProducts,
+      homeCategories: categoriesResolved ? resolvedCategories : state.homeCategories ?? [],
       ...bookings,
       ...extras,
       ...saved,
@@ -1075,6 +1100,7 @@ async function refreshPublic(state: State, arg?: unknown): Promise<State | undef
       // genuine store outage still raises the banner.
       isErrored: keptProducts.length === 0 && !isBridgeUnavailable(e),
       featuredProducts: keptProducts,
+      homeCategories: categoriesResolved ? resolvedCategories : state.homeCategories ?? [],
       welcome: welcome(),
       refreshedAt: new Date().toISOString(),
       ...bookings,
@@ -1087,6 +1113,7 @@ async function refreshPublic(state: State, arg?: unknown): Promise<State | undef
 }
 
 let personalGeneration = 0;
+let shopCategoryActivation = 0;
 function memberSchedule(rows: MemberBookingRow[], now = new Date()): { label: string; fraction: number } {
   const weekStart = new Date(now);
   const day = (weekStart.getDay() + 6) % 7;
@@ -1184,20 +1211,33 @@ const svc = defineService<State, {
   refresh: (state: State, arg?: unknown) => Promise<State | undefined>;
   dismissOnboarding: (state: State) => State;
   clearPersonal: (state: State) => State;
+  openShopCategory: (state: State, arg?: unknown) => State;
   personalLoaded: (state: State, arg: { generation: number; rows: MemberBookingRow[]; progress: { label: string; fraction: number }; error: boolean; weekly: { count: number; fraction: number; label: string } | null }) => State;
+  categoriesLoaded: (state: State, arg: { generation: number; categories: StoreCategoryCard[] }) => State | undefined;
 }>("himiBrandedHome", {
   state: baseState(),
   // The host's site is read fresh at every boot: a snapshot of the last session's site must not
   // decide this one's verticals or name (an owner installs or removes one; another site opens).
-  notHydrated: ["hosted", "hostedName", "hostedCards"],
+  notHydrated: ["hosted", "hostedName", "hostedCards", "homeCategories", "noHomeCategories"],
   actions: {
     clearPersonal: state => derive({ ...state, nextBooking: [], hideNextBooking: true, memberProgressLabel: "", memberProgressFraction: 0, hideMemberProgress: true, personalError: false, hidePersonalError: true,
       weeklyClassCount: 0, weeklyClassGoalFraction: 0, weeklyGoalLabel: "" }),
+    openShopCategory: (state, arg) => {
+      const category = String((arg as { category?: unknown } | undefined)?.category ?? "");
+      if (!category) return state;
+      shopCategoryActivation++;
+      // Nav params are strings and the activation nonce is a transient route event,
+      // not a distinct Shop record. ScreenHost forwards these live params to onAppear
+      // when a pooled worker is reused.
+      const activation = `${Date.now()}-${shopCategoryActivation}`;
+      return navigate(state, { screenId: "himi_shop", args: { category, categoryId: category, categoryActivation: activation } });
+    },
     personalLoaded: (state, arg) => arg.generation !== personalGeneration ? state : derive({ ...state,
       nextBooking: arg.rows, hideNextBooking: !arg.rows.length,
       memberProgressLabel: arg.progress.label, memberProgressFraction: arg.progress.fraction, hideMemberProgress: !arg.progress.label,
       personalError: arg.error, hidePersonalError: !arg.error,
       weeklyClassCount: arg.weekly?.count ?? 0, weeklyClassGoalFraction: arg.weekly?.fraction ?? 0, weeklyGoalLabel: arg.weekly?.label ?? "" }),
+    categoriesLoaded: (state, arg) => arg.generation !== refreshGen ? undefined : derive({ ...state, homeCategories: arg.categories }),
     refresh,
     // "Got it" on the first-run card: persist + hide. Persistence is
     // best-effort — the UI hides either way for this session.
@@ -1213,7 +1253,7 @@ const svc = defineService<State, {
 // name. In place, because on those runtimes getState() IS the stored state (as himi-player-home does).
 if ((globalThis as { himalaya?: { hydrationOptOut?: unknown } }).himalaya?.hydrationOptOut !== true) {
   const live = (svc as { getState?: () => State | undefined }).getState?.();
-  if (live && typeof live === "object") Object.assign(live, hostedBoot);
+  if (live && typeof live === "object") Object.assign(live, hostedBoot, { homeCategories: [], noHomeCategories: true });
 }
 
 svc.refresh();