@wix/himalaya-cli 0.1446.0 → 0.1447.0

package/templates/yoga-studio-owner/tier5-src/_shared/collection-service.ts

@@ -142,6 +142,7 @@ export function decorateCollection(name: string, def: { state: State; actions?:
     // the query controller carries a recoverable failure. Treat each shape as
     // one collection state so the shared UI never renders a blank catalog.
     const backendState = backend?.controller.getState();
+    const provisional = backendState?.provisional === true;
     const errored = s.status === 'error' || s.isErrored === true || s.errored === true || backendState?.status === 'error';
     const domainError = typeof s.error === 'string' ? s.error.trim() : '';
     const queryError = typeof backendState?.error === 'string' ? backendState.error.trim() : '';
@@ -177,13 +178,17 @@ export function decorateCollection(name: string, def: { state: State; actions?:
     // un-narrowed failure. A re-query while typing keeps it (and the search field's focus).
     const hideChrome = (!narrowed && !s.nextCursor && projected.loaded < COLLECTION_CHROME_MIN_ITEMS)
       || sourceEmpty || ((loading || errored) && rows.length === 0 && !narrowed);
-    return { ...s, collection: { ...prefs, ...projected,
+    // Kept with the state, so a cold boot restored from disk shows its last page and revalidates behind it.
+    const collectionShown = backend?.controller.shownPage();
+    return { ...s, ...(backend ? { collectionShown: collectionShown ?? null } : {}), collection: { ...prefs, ...projected,
       hideChrome, noActiveCriteria: !narrowed,
       viewName, viewMessage, saveMessage, noSavedViews: prefs.savedViews.length === 0,
       cursor: s.pageError === true || s.loadingMore === true ? '' : s.nextCursor,
       noMore: !s.nextCursor || s.pageError === true || s.loadingMore === true,
       noPageError: s.pageError !== true,
-      noOffline: s.fromCache !== true,
+      // Rows read from the device ahead of the live read are shown as they are: "saved offline" is what stays on
+      // screen when the live read failed, not a first visit that is still loading.
+      noOffline: s.fromCache !== true || provisional,
       noError: !errored,
       noRetry: !canRetry || signInRequired,
       noSignIn: !signInRequired,
@@ -202,7 +207,7 @@ export function decorateCollection(name: string, def: { state: State; actions?:
       filtersPresented, previewPresented: !!previewId, preview: projected.items.filter(row => row.collectionId === previewId),
       persistenceLabel: persisted.available ? copyParam('collection.onDevice', 'Saved on this device') : copyParam('collection.sessionOnly', 'Choices last for this session'),
       noEmpty: loading || errored || sourceEmpty || domainNarrowed || projected.items.length > 0,
-      summary: backend && config.backendQuery && s.fromCache
+      summary: backend && config.backendQuery && s.fromCache && !provisional
         ? copyParam('collection.cached', 'Saved offline · may be outdated')
         : collectionSummary({ shown: projected.items.length, loaded: projected.loaded, backend: !!(backend && config.backendQuery),
           total: typeof s.total === 'number' ? s.total : undefined, noun: config.countNoun
@@ -345,6 +350,13 @@ export function defineBackendCollection<S extends object, Row extends object>(na
     apply: (state, page) => options.apply(state as S, page as unknown as CollectionQueryState<Row>) as State,
   });
   const handle = (options.register ?? register)(name, definition);
+  // Registration restored the state a cold boot saved: the page it showed is this run's, before the first load. Only
+  // when the service's own rows came back with it: a bundle that keeps them out of the restore (its `notHydrated`)
+  // starts its first load as before, never from rows it chose not to restore.
+  const restored = (handle as { getState?: () => State }).getState?.();
+  const rowsKey = COLLECTIONS[name]?.rows;
+  const restoredRows = rowsKey ? restored?.[rowsKey] : undefined;
+  if (Array.isArray(restoredRows) && restoredRows.length > 0) controller.seed(restored?.collectionShown);
   publish = () => handle.collectionDataChanged();
   return handle;
 }

package/templates/yoga-studio-owner/tier5-src/himi-owner-lite-manage/index.ts

@@ -17,7 +17,7 @@ import { OWNER_MODULES, ownerModuleId } from '../_shared/owner-modules.js';
 import { localPreferences } from '../_shared/local-preferences.js';
 import { stashCopy, copyParam, copyTemplate } from '../_shared/himi-copy.js';
 import { fallbackNameFrom, selectedSiteName } from '../_shared/owner-selected-site.js';
-import { DASHBOARD_PATHS, deriveManage, parseAreas, recentAreas, rememberArea, withMetrics, type ManageArea, type Metric } from './logic.js';
+import { DASHBOARD_PATHS, deriveManage, parseAreas, recentAreas, metricFailure, rememberArea, withMetrics, type ManageArea, type Metric, type MetricFailure } from './logic.js';
 
 interface State {
   /** The business the header names: the one picked on Sites, else the descriptor's
@@ -43,7 +43,6 @@ interface State {
   noSections: boolean;
   isLoading: boolean;
   notLoading: boolean;
-  summaryNote: string;
   handoffError: string;
 }
 
@@ -242,20 +241,26 @@ async function loadMetrics(state: State): Promise<State> {
   return newestStarted ?? settled;
 }
 
+/** A row's status when its summary could not load: why, so a missing app or a denied read is not taken for a fault. */
+function failureText(failure: MetricFailure): string {
+  switch (failure) {
+    case 'notSetUp': return copyParam('ownerManage.notSetUp', 'Not set up on this site');
+    case 'noAccess': return copyParam('ownerManage.noAccess', 'No access');
+    default: return copyParam('ownerManage.summaryUnavailable', 'Couldn’t load summary');
+  }
+}
+
 async function readMetrics(state: State): Promise<State> {
   const keys = [...new Set(state.areas.map(area => area.metricKey))];
   const settled = await Promise.allSettled(keys.map(metricFor));
   const metrics: Record<string, Metric | undefined> = {};
-  const unavailable = new Set<string>();
+  const failures = new Map<string, string>();
   settled.forEach((result, index) => {
     if (result.status === 'fulfilled') metrics[keys[index]] = result.value;
-    else unavailable.add(keys[index]);
+    else failures.set(keys[index], failureText(metricFailure(result.reason)));
   });
-  const areas = withMetrics(state.areas, metrics, unavailable);
-  const note = unavailable.size
-    ? copyParam('ownerManage.partialSummary', 'Some summaries couldn’t load. You can still open every business area.')
-    : '';
-  return derive({ ...state, areas, isLoading: false, notLoading: true, summaryNote: note, handoffError: '' }, areas);
+  const areas = withMetrics(state.areas, metrics, failures);
+  return derive({ ...state, areas, isLoading: false, notLoading: true, handoffError: '' }, areas);
 }
 
 function findArea(state: State, arg: unknown): ManageArea | undefined {
@@ -294,7 +299,7 @@ const svc = defineService<State, {
     // 'All' is always a valid filter, so the chip row paints from the first frame
     // instead of appearing (and shifting the layout) when the areas arrive.
     groups: [{ id: 'all', label: allLabel() }], summary: '', noEmpty: true,
-    hasRecents: false, noRecents: true, noSections: true, isLoading: true, notLoading: false, summaryNote: '', handoffError: '',
+    hasRecents: false, noRecents: true, noSections: true, isLoading: true, notLoading: false, handoffError: '',
   },
   actions: {
     load: async (state, arg) => {
@@ -313,7 +318,7 @@ const svc = defineService<State, {
       const parsed = (() => { try { return JSON.parse(str(arg, 'areas') || '[]'); } catch { return []; } })();
       const areas = parseAreas(parsed);
       if (state.status === 'ready' && sameAreas(state.areas, areas)) return loadMetrics(revalidating(state, areas));
-      return loadMetrics(derive({ ...state, status: 'ready', areas, isLoading: true, notLoading: false, summaryNote: '', handoffError: '' }, areas));
+      return loadMetrics(derive({ ...state, status: 'ready', areas, isLoading: true, notLoading: false, handoffError: '' }, areas));
     },
     // Refresh re-reads summaries for KNOWN areas. Before the descriptor has
     // delivered them there is nothing to refresh, and settling here would open
@@ -321,7 +326,7 @@ const svc = defineService<State, {
     // it is re-read either way.
     refresh: async state => {
       currentBusinessName = selectedSiteName(fallbackBusinessName);
-      return state.status !== 'ready' ? { ...state, businessName: currentBusinessName } : loadMetrics(derive({ ...state, isLoading: true, notLoading: false, summaryNote: '', handoffError: '' }));
+      return state.status !== 'ready' ? { ...state, businessName: currentBusinessName } : loadMetrics(derive({ ...state, isLoading: true, notLoading: false, handoffError: '' }));
     },
     search: (state, arg) => derive({ ...state, query: str(arg, 'value').slice(0, 256) }),
     filter: (state, arg) => {

package/templates/yoga-studio-owner/tier5-src/himi-owner-lite-manage/logic.ts

@@ -110,13 +110,26 @@ export function countText(metric: Metric, label: string): string {
   return `${count}${metric.hasMore ? "+" : ""} ${label}`;
 }
 
-/** Apply independently loaded metrics. A failed source stays visibly unknown;
- * it never becomes a misleading zero. */
-export function withMetrics(areas: ManageArea[], metrics: Record<string, Metric | undefined>, unavailable: Set<string>): ManageArea[] {
+/** Why a summary could not load: the area's app is not on the site, the owner may not read it, or the read failed.
+ *  From the LEADING status only, as Today reads it (`isSectionUnavailable`): a transient
+ *  `HTTP 503: {"message":"upstream returned 404"}` is a failure, not a missing app. */
+export type MetricFailure = "notSetUp" | "noAccess" | "failed";
+
+export function metricFailure(error: unknown): MetricFailure {
+  const text = String((error as Error)?.message ?? error);
+  if (/^HTTP (?:404|428)\b/.test(text) || /^HTTP \d{3} \[FAILED_PRECONDITION\]/.test(text)) return "notSetUp";
+  if (/^HTTP 403\b/.test(text) || /^HTTP \d{3} \[PERMISSION_DENIED\]/.test(text)) return "noAccess";
+  return "failed";
+}
+
+/** Apply independently loaded metrics. A failed source stays visibly unknown, saying why on its own row
+ * ([failures]: metric key → that row's status); it never becomes a misleading zero. */
+export function withMetrics(areas: ManageArea[], metrics: Record<string, Metric | undefined>, failures: Map<string, string>): ManageArea[] {
   return areas.map(area => {
     const metric = metrics[area.metricKey];
-    if (!metric || unavailable.has(area.metricKey)) {
-      return { ...area, metricText: "—", statusText: "Couldn’t load summary", unavailable: true };
+    const failure = failures.get(area.metricKey);
+    if (!metric || failure !== undefined) {
+      return { ...area, metricText: "—", statusText: failure ?? "", unavailable: true };
     }
     return {
       ...area,