@wix/himalaya-cli 0.1242.0 → 0.1244.0

package/templates/branded-lite/tier5-src/himi-branded-lite-programs/index.ts

@@ -6,11 +6,19 @@
 // self-contained (name, cover, description snippet, cheap meta) — no detail
 // screen; enrolling stays a hosted-site flow.
 // Four-state (loading / error / rows / empty) like the sibling branded workers.
-import { defineService } from "../_shared/collection-service.js";
+//
+// App Store prices come from the shared IAP catalog layer (@himalaya/iap). Until a mapping backend
+// is connected it is disabled, and this worker runs exactly its pre-pricing path.
+import { defineService as register } from "@himalaya/state";
+import { decorateCollection } from "../_shared/collection-service.js";
 import { queryPrograms, type WixProgram } from "@himalaya/wix-online-programs";
+import { createIapCatalogPricing, iapPriceFields, onlineProgramItem, type IapPollDirective } from "@himalaya/iap";
 import { wixMediaUrl } from "@himalaya/wix-media";
 import { cleanTitle, initials } from "../_shared/himi-text.js";
 import { copyParam, stashCopy } from "../_shared/himi-copy.js";
+import { hostIapScope, hostScopeComplete, iapPriceCopy, resetUnhydratedKeysOnOlderRuntime } from "../_shared/iap-worker.js";
+
+const SERVICE = "himiBrandedPrograms";
 
 interface ProgramRow {
   id: string;
@@ -27,6 +35,15 @@ interface ProgramRow {
   noImage: boolean;
   /** Templated in-app program detail — rows tap through (no more dead wall). */
   detailScreenId: string;
+  /** This run's App Store price or its loading/unavailable label; "" when pricing is off. The
+   *  collection card shows it in the caption ahead of `meta`. */
+  priceLine: string;
+}
+
+/** A row as loaded, before pricing — the half that may be restored from a cold-boot snapshot. */
+interface ProgramContent extends Omit<ProgramRow, "priceLine"> {
+  /** The Wix ID, or "" when the row fell back to its title and so cannot be priced. */
+  wixId: string;
 }
 
 interface State {
@@ -40,6 +57,13 @@ interface State {
   hasRows: boolean;
   noRows: boolean;
   noEmpty: boolean;
+  hidePriceRetry: boolean;
+  /** Beside the list-level Retry, so it says what failed. */
+  priceRetryText: string;
+  programs?: ProgramContent[];
+  /** Derived from `rows` by the collection decorator. */
+  collection?: unknown;
+  _poll?: IapPollDirective;
 }
 
 /** v3 nests display fields under `description`/`settings`; older shapes are
@@ -86,7 +110,7 @@ function isDraft(p: WixProgram): boolean {
   return state === "DRAFT";
 }
 
-function programRow(p: WixProgram): ProgramRow {
+function programFields(p: WixProgram): Omit<ProgramRow, "priceLine"> {
   const name = programTitle(p);
   const image = programImage(p);
   const id = p.id || name;
@@ -109,6 +133,14 @@ function programRow(p: WixProgram): ProgramRow {
   };
 }
 
+function programRow(p: WixProgram): ProgramRow {
+  return { ...programFields(p), priceLine: "" };
+}
+
+function programContent(p: WixProgram): ProgramContent {
+  return { ...programFields(p), wixId: p.id ?? "" };
+}
+
 function ready(rows: ProgramRow[]): State {
   return {
     status: "ready",
@@ -121,46 +153,134 @@ function ready(rows: ProgramRow[]): State {
     hasRows: rows.length > 0,
     noRows: rows.length === 0,
     noEmpty: rows.length > 0,
+    hidePriceRetry: true,
+    priceRetryText: "",
   };
 }
 
-const svc = defineService<State, {
-  load: (state: State, arg?: unknown) => Promise<State>;
-}>("himiBrandedPrograms", {
-  state: {
-    status: "loading",
-    rows: [],
-    emptyText: "",
-    isLoading: true,
-    notLoading: false,
-    isErrored: false,
-    notErrored: true,
-    hasRows: false,
-    noRows: true,
+// Bridge errors land here — a graceful error card with retry, never a dead
+// screen (the branded four-state contract).
+function errored(state: State): State {
+  return {
+    ...state,
+    status: "error",
+    isLoading: false,
+    notLoading: true,
+    isErrored: true,
+    notErrored: false,
     noEmpty: true,
-  },
-  actions: {
-    load: async (state, arg) => {
-      stashCopy(arg);
-      try {
-        const response = await queryPrograms({ cursorPaging: { limit: 50 } });
-        return ready((response.programs ?? []).filter((p) => !isDraft(p)).map(programRow));
-      } catch {
-        // Bridge errors land here — a graceful error card with retry, never a
-        // dead screen (the branded four-state contract).
-        return {
-          ...state,
-          status: "error",
-          isLoading: false,
-          notLoading: true,
-          isErrored: true,
-          notErrored: false,
-          noEmpty: true,
-        };
-      }
-    },
-  },
-});
+  };
+}
+
+async function fetchPrograms(): Promise<WixProgram[]> {
+  const response = await queryPrograms({ cursorPaging: { limit: 50 } });
+  return (response.programs ?? []).filter((p) => !isDraft(p));
+}
+
+async function load(state: State, arg?: unknown): Promise<State> {
+  stashCopy(arg);
+  try {
+    return ready((await fetchPrograms()).map(programRow));
+  } catch {
+    return errored(state);
+  }
+}
+
+// ── App Store pricing (enabled only when a mapping backend is connected) ─────
+//
+// One writer: `loadPriced` keeps its content here and every state change goes through the
+// synchronous `pricingPublish`, which re-reads the latest content and prices. An async action
+// that returned its own state could land after a newer publication and repaint stale prices.
+
+const pricing = createIapCatalogPricing({ onChange: () => { void svc.pricingPublish(); } });
+const PRICING_NOT_HYDRATED = ["rows", "collection", "hidePriceRetry"] as const;
+let content: { status: State["status"]; programs: ProgramContent[] } = { status: "loading", programs: [] };
+let scopeIncomplete = false;
+let loadSeq = 0;
+
+async function loadPriced(_state: State, arg?: unknown): Promise<undefined> {
+  stashCopy(arg);
+  const seq = ++loadSeq;
+  const programs = await fetchPrograms().catch(() => undefined);
+  if (seq !== loadSeq) return undefined;
+  content = programs ? { status: "ready", programs: programs.map(programContent) } : { ...content, status: "error" };
+  void svc.pricingPublish();
+  if (programs) void priceContent();
+  return undefined;
+}
+
+/** Prices the programs on screen now. Content never waits on this, and the host scope is re-read
+ *  each time, so a failed app-info read recovers on the next refresh. */
+async function priceContent(): Promise<void> {
+  // The Retry action is declared in both modes; with no backend it must not reach the host.
+  if (!pricing.enabled) return;
+  const host = await hostIapScope();
+  scopeIncomplete = !hostScopeComplete(host);
+  if (content.status !== "ready") return;
+  await pricing.load({ ...host, items: content.programs.flatMap((program) => onlineProgramItem({ id: program.wixId }) ?? []) });
+}
+
+function pricedState(state: State): State {
+  const copy = iapPriceCopy("programs");
+  const views = content.programs.map((program) => {
+    const item = onlineProgramItem({ id: program.wixId });
+    return item ? pricing.view(item.reference) : undefined;
+  });
+  const rows = content.programs.map(({ wixId: _wixId, ...row }, i) =>
+    ({ ...row, priceLine: views[i] ? iapPriceFields(views[i]!, copy).priceText : "" }));
+  const shown = content.status === "ready" ? ready(rows) : content.status === "error" ? errored({ ...state, rows }) : INITIAL_STATE;
+  return {
+    ...state, ...shown, programs: content.programs,
+    // Retry re-prices the programs on screen, which only a ready list has.
+    hidePriceRetry: content.status !== "ready" || !views.some((view) => view && (scopeIncomplete || view.retryable)),
+    priceRetryText: copyParam("programs.priceRetryText", "Some prices could not be loaded."),
+  };
+}
+
+const INITIAL_STATE: State = {
+  status: "loading",
+  rows: [],
+  emptyText: "",
+  isLoading: true,
+  notLoading: false,
+  isErrored: false,
+  notErrored: true,
+  hasRows: false,
+  noRows: true,
+  noEmpty: true,
+  hidePriceRetry: true,
+  priceRetryText: "",
+};
+
+type Actions = {
+  load: (state: State, arg?: unknown) => Promise<State | undefined>;
+  pricingPublish: (state: State) => State;
+  pricingStart: (state: State) => State;
+  pricingRefresh: (state: State) => Promise<undefined>;
+};
+
+const actions: Actions = {
+  load: pricing.enabled ? loadPriced : load,
+  pricingPublish: pricedState,
+  pricingStart: (state) => ({ ...pricedState(state), _poll: pricing.pollDirective(`${SERVICE}.pricingRefresh`) }),
+  pricingRefresh: async () => { await priceContent(); return undefined; },
+};
+
+// The collection decorator's own `defineService` drops `notHydrated`, so the decorated definition
+// is registered directly: this run's prices must never be restored from a cold-boot snapshot.
+const decorated = decorateCollection(SERVICE, { state: INITIAL_STATE, actions } as unknown as Parameters<typeof decorateCollection>[1]);
+const svc = register<State, Actions>(SERVICE, (pricing.enabled
+  ? { ...decorated, notHydrated: [...PRICING_NOT_HYDRATED] }
+  : decorated) as unknown as Parameters<typeof register<State, Actions>>[1]);
+
+if (pricing.enabled) {
+  const booted = svc.getState();
+  if ((booted.status === "ready" || booted.status === "error") && Array.isArray(booted.programs)) {
+    content = { status: booted.status, programs: booted.programs };
+  }
+  resetUnhydratedKeysOnOlderRuntime(svc, decorated.state as unknown as State, PRICING_NOT_HYDRATED);
+  void svc.pricingStart();
+}
 
 // Kick the first load at module scope, like every other list bundle
 // (himi-store-shop, himi-booking-services, himi-events-list, himi-blog-feed …).

package/templates/yoga-studio/dev/index.ts

@@ -11598,6 +11598,65 @@ const SCREENS = runtimeSetting({
                 "hiddenPath": "$service:himiBrandedPrograms.notErrored"
               }
             },
+            {
+              "id": "himi_programs.price_retry_card",
+              "body": {
+                "package": "himalaya",
+                "type": "VStack",
+                "props": {
+                  "spacing": 8,
+                  "alignment": "leading",
+                  "children": [
+                    {
+                      "id": "himi_programs.price_retry_text",
+                      "body": {
+                        "package": "himalaya",
+                        "type": "Text",
+                        "props": {
+                          "text": "$service:himiBrandedPrograms.priceRetryText",
+                          "style": "footnote",
+                          "color": "textSecondary",
+                          "collapseWhenEmpty": true
+                        }
+                      }
+                    },
+                    {
+                      "id": "himi_programs.price_retry",
+                      "body": {
+                        "package": "himalaya",
+                        "type": "Button",
+                        "props": {
+                          "title": "Try again",
+                          "style": "secondary",
+                          "action": {
+                            "actionId": "tier5.himiBrandedPrograms.pricingRefresh"
+                          }
+                        }
+                      }
+                    }
+                  ]
+                }
+              },
+              "modifiers": {
+                "background": {
+                  "token": "surfaceElevated"
+                },
+                "border": {
+                  "width": 1,
+                  "color": {
+                    "token": "border"
+                  }
+                },
+                "cornerRadius": 16,
+                "padding": {
+                  "leading": 16,
+                  "trailing": 16,
+                  "top": 16,
+                  "bottom": 16
+                },
+                "hiddenPath": "$service:himiBrandedPrograms.hidePriceRetry"
+              }
+            },
             {
               "id": "himi_programs.rows.collection.toolbar",
               "body": {
@@ -13953,7 +14012,9 @@ const SCREENS = runtimeSetting({
       "integrity": "",
       "contentType": "application/javascript+ts-bundle",
       "declaredCapabilities": [
-        "wix_api"
+        "wix_api",
+        "iap",
+        "app_info"
       ],
       "minBinaryVersion": "0.1.0",
       "bundleVersion": "0.0.1"
@@ -25931,7 +25992,7 @@ const TEMPLATED: { pattern: string; display: string; liveSeed?: LiveSeed; static
                       }
                     },
                     {
-                      "id": "",
+                      "id": "himi_program.price",
                       "body": {
                         "package": "himalaya",
                         "type": "Text",
@@ -25943,6 +26004,36 @@ const TEMPLATED: { pattern: string; display: string; liveSeed?: LiveSeed; static
                         }
                       }
                     },
+                    {
+                      "id": "himi_program.price_note",
+                      "body": {
+                        "package": "himalaya",
+                        "type": "Text",
+                        "props": {
+                          "text": "$service:himiBrandedProgram.priceNote",
+                          "style": "caption",
+                          "color": "textSecondary",
+                          "collapseWhenEmpty": true
+                        }
+                      }
+                    },
+                    {
+                      "id": "himi_program.price_retry",
+                      "body": {
+                        "package": "himalaya",
+                        "type": "Button",
+                        "props": {
+                          "title": "Try again",
+                          "style": "secondary",
+                          "action": {
+                            "actionId": "tier5.himiBrandedProgram.pricingRefresh"
+                          }
+                        }
+                      },
+                      "modifiers": {
+                        "hiddenPath": "$service:himiBrandedProgram.hidePriceRetry"
+                      }
+                    },
                     {
                       "id": "",
                       "body": {
@@ -25997,12 +26088,26 @@ const TEMPLATED: { pattern: string; display: string; liveSeed?: LiveSeed; static
                           "title": "Enrol",
                           "style": "primary",
                           "fullWidth": true,
+                          "disabledPath": "$service:himiBrandedProgram.enrollDisabled",
                           "action": {
                             "actionId": "tier5.himiBrandedProgram.enroll"
                           }
                         }
                       }
                     },
+                    {
+                      "id": "himi_program.enrol_note",
+                      "body": {
+                        "package": "himalaya",
+                        "type": "Text",
+                        "props": {
+                          "text": "$service:himiBrandedProgram.enrollNote",
+                          "style": "footnote",
+                          "color": "textSecondary",
+                          "collapseWhenEmpty": true
+                        }
+                      }
+                    },
                     {
                       "id": "himi_program.action_message",
                       "body": {
@@ -26142,7 +26247,9 @@ const TEMPLATED: { pattern: string; display: string; liveSeed?: LiveSeed; static
         "wix_api",
         "wix_cashier",
         "open_url",
-        "wix_platform"
+        "wix_platform",
+        "iap",
+        "app_info"
       ],
       "minBinaryVersion": "0.1.0",
       "bundleVersion": "0.0.1"

package/templates/yoga-studio/tier5-src/_shared/iap-worker.ts

@@ -0,0 +1,65 @@
+// Worker-side glue for the shared IAP catalog layer (`@himalaya/iap` → createIapCatalogPricing),
+// shared by every screen that shows or sells an IAP-backed item. Mapping, Apple prices and payment
+// guards live in the SDK; this only supplies the host scope, the copy, and the hydration reset.
+import { get as appInfo } from "@himalaya/app-info";
+import type { IapCatalogScope, IapPriceCopy } from "@himalaya/iap";
+import { copyParam } from "./himi-copy.js";
+
+export interface HostIapScope {
+  scope: IapCatalogScope;
+  platform: string;
+}
+
+let hostScope: Promise<HostIapScope> | undefined;
+
+/** Read once per worker, and only by an enabled screen: a disabled one makes no app-info call.
+ *  App identity and platform come from the host, never a screen param. The site is the host-owned
+ *  native preference business (the web partition uses an OAuth client ID); without one, the mapping source's
+ *  bound site applies. A failed read leaves identity empty, which fails every item closed — and is
+ *  not kept, so the next lookup asks the host again instead of staying invalid for good. */
+export function hostIapScope(): Promise<HostIapScope> {
+  return hostScope ??= readHostScope().then((read) => {
+    if (!hostScopeComplete(read)) hostScope = undefined;
+    return read;
+  });
+}
+
+/** An incomplete scope prices every item `invalidInput`, which the shared layer never offers to
+ *  retry — so a screen offers Retry itself while its own host read is what failed. */
+export function hostScopeComplete(read: HostIapScope): boolean {
+  return !!read.scope.appId && !!read.scope.bundleId && !!read.platform;
+}
+
+async function readHostScope(): Promise<HostIapScope> {
+  const identity = await appInfo().catch(() => undefined);
+  const siteId = identity?.platform === "web" ? "" : hostSiteId();
+  return {
+    scope: { appId: identity?.appId ?? "", bundleId: identity?.bundleId ?? "", ...(siteId ? { siteId } : {}) },
+    platform: identity?.platform ?? "",
+  };
+}
+
+function hostSiteId(): string {
+  const value = (globalThis as { himalaya?: { input?: Record<string, unknown> } }).himalaya?.input?.__himiPreferenceBusiness;
+  return typeof value === "string" ? value.trim() : "";
+}
+
+/** Price labels from the screen's copy pack (`<prefix>.priceLoadingText`, …). */
+export function iapPriceCopy(prefix: string): IapPriceCopy {
+  return {
+    loading: copyParam(`${prefix}.priceLoadingText`, "Loading price…"),
+    unavailable: copyParam(`${prefix}.priceUnavailableText`, "Price unavailable"),
+    oneTimePurchase: copyParam(`${prefix}.oneTimePurchaseLabel`, "One-time purchase"),
+    purchaseUnavailable: copyParam(`${prefix}.purchaseUnavailableText`, "Purchasing is not available yet."),
+  };
+}
+
+/** What `notHydrated` does, for a runtime that ignores the option (a binary older than it, still
+ *  served new bundles): put the listed keys back to their declared values before any action runs,
+ *  so a persisted price or an enabled purchase action never paints as this run's. */
+export function resetUnhydratedKeysOnOlderRuntime<S extends object>(svc: { getState(): S }, declared: S, keys: readonly (keyof S & string)[]): void {
+  if ((globalThis as { himalaya?: { hydrationOptOut?: unknown } }).himalaya?.hydrationOptOut === true) return;
+  const booted = svc.getState();
+  if (!booted || typeof booted !== "object") return;
+  for (const key of keys) booted[key] = declared[key];
+}