@wix/himalaya-cli 0.1465.0 → 0.1467.0

package/guides/search-list.service.ts

@@ -6,8 +6,9 @@
 // the current query, and let the SearchField's debounced onChange action swap
 // what the single bound path holds. The descriptor never rebinds anything.
 //
-// Builds on the dynamic-list recipe (worker owns the array, four-state display
-// strings) — see examples/dynamic-list.* for that base. Declares "wix_api".
+// Builds on the dynamic-list recipe (worker owns the array, one hiddenPath flag per
+// state, classified errors) — see examples/dynamic-list.* for that base. A retry
+// keeps the user's query. Declares "wix_api".
 
 import { defineService } from "@wix/himalaya/state";
 import { queryPosts, type WixPost } from "@wix/himalaya/wix-blog";
@@ -20,15 +21,24 @@ interface PostRow {
   categoryIds: string[];
 }
 
+// A public blog has no sign-in flow, so a 401 reads as "permission" here.
+type ErrorKind = "" | "offline" | "server" | "permission";
+
 interface PostsState {
   status: "loading" | "ready" | "error";
   all: PostRow[];   // the full fetched set — NOT bound by the descriptor
   items: PostRow[]; // ← itemsPath binds here; ALWAYS derived from all + query
   query: string;
-  loadingText: string;
-  emptyText: string; // distinguishes "no data" from "no matches"
-  error: string;
-  notErrored: boolean;
+  errorKind: ErrorKind;
+  // hiddenPath flags (hide when TRUE) — see `himi docs recipe-four-state`
+  hideLoading: boolean;
+  hideNoPosts: boolean;   // EmptyState: the blog has no posts at all
+  hideNoMatches: boolean; // EmptyState: posts exist, none match the query (not an error)
+  notEmpty: boolean;      // false while either EmptyState shows
+  hideOfflineError: boolean;
+  hideServerError: boolean;
+  hidePermissionError: boolean;
+  hideRefreshError: boolean;
 }
 
 function normalize(raw: WixPost): PostRow {
@@ -54,38 +64,78 @@ function shape(s: Partial<PostsState>): PostsState {
   const all = s.all ?? [];
   const query = s.query ?? "";
   const items = s.items ?? visible(all, query);
+  const errorKind: ErrorKind = status === "error" ? (s.errorKind || "server") : "";
+  const blank = all.length === 0; // nothing loaded to keep
   return {
     status,
     all,
     items,
     query,
-    loadingText: status === "loading" ? "Loading posts…" : "",
-    emptyText:
-      status === "ready" && items.length === 0
-        ? query
-          ? `No matches for “${query}”.`
-          : "No posts yet."
-        : "",
-    error: s.error ?? "",
-    notErrored: status !== "error",
+    errorKind,
+    // Two EmptyStates, not one bound Text: iOS/Android do not bind EmptyState text.
+    hideNoPosts: !(status === "ready" && blank),
+    // Over rows kept after a failed refresh too: no matches is still empty, not an error.
+    hideNoMatches: !(!blank && items.length === 0),
+    notEmpty: !((status === "ready" && blank) || (!blank && items.length === 0)),
+    hideLoading: !(status === "loading" && blank),
+    hideOfflineError: !(blank && errorKind === "offline"),
+    hideServerError: !(blank && errorKind === "server"),
+    hidePermissionError: !(blank && errorKind === "permission"),
+    hideRefreshError: !(!blank && (errorKind === "offline" || errorKind === "server")),
   };
 }
 
+// The HTTP status rides in the message: `HTTP 503: …` on a device, `Wix 503 for …`
+// under `himi test` / `himi render`. Only a transport failure is "offline".
+const STATUS = /\b(?:HTTP|Wix) (\d{3})\b/;
+// No answer at all — what a dropped connection says on every platform.
+const TRANSPORT = /NSURLErrorDomain|(?:UnknownHost|Connect|SocketTimeout|NoRouteToHost|SSLHandshake)Exception|Failed to connect|Unable to resolve host|Connection (?:refused|reset)|Network is unreachable|Software caused connection abort|ECONNRESET|ETIMEDOUT|EPIPE|Broken pipe|stream was reset|unexpected end of stream|timed out|^timeout$|Failed to fetch|NetworkError|^(?:TypeError: )?Load failed$|net::ERR_|^[a-z0-9-]+(?:\.[a-z0-9-]+)+$/i;
+// Android reports an unknown host as the bare hostname (`users.wix.com`) — hence the last form.
+// No session on the device: the native bridge refuses before any request leaves.
+// A pinned site with no member session: iOS `siteNotPermitted(requested: "account", …)`,
+// Android `site account is not the bound site …`; the web host `HTTP 501: {"error":"webwix_owner_no_session"}`.
+const SIGNED_OUT = /wixApi not enabled|session unavailable|PRINCIPAL_CHANGED|not signed in|siteNotPermitted\(requested: "account"|site account is not the bound site|webwix_owner_no_session/i;
+
+// The same classifier as `himi docs recipe-four-state`, except that a public screen with no sign-in flow shows the permission state for a sign-in failure.
+function classifyError(e: unknown): ErrorKind {
+  const msg = String((e as Error)?.message ?? e ?? "");
+  const code = String((e as { code?: unknown })?.code ?? "");
+  const status = Number(STATUS.exec(msg)?.[1] ?? 0);
+  if (status === 401) return "permission";
+  if (status === 403) return "permission";
+  if (SIGNED_OUT.test(msg)) return "permission";
+  if (code === "offline_write_blocked") return "offline"; // a write refused before it left
+  // A web call that never reached Wix arrives as
+  // `HTTP 502: {"error":"webwix_direct_failed","detail":"Failed to fetch"}` — judge its detail.
+  if (status && !msg.includes("webwix_direct_failed")) return "server";
+  if (TRANSPORT.test(msg)) return "offline";
+  return "server"; // a bug or a malformed row is not the user's connection
+}
+
 // The SearchField onChange arg shape varies by surface — read it defensively.
 function queryFrom(arg: unknown): string {
   const a = arg as { value?: string; text?: string; query?: string } | undefined;
   return String(a?.value ?? a?.text ?? a?.query ?? "");
 }
 
-async function loadList(): Promise<PostsState> {
+// Actions are not serialized: the user can type while load() is in flight, and the
+// action that finishes last writes the whole state. So the latest query lives outside
+// the state, and the fetch applies it when it returns — a retry or a slow first load
+// never throws away what the user typed.
+let currentQuery = "";
+
+async function loadList(s: Partial<PostsState>): Promise<PostsState> {
   try {
     const res = await queryPosts({ query: { paging: { limit: 100 } } });
     const all = ((res as { posts?: WixPost[] }).posts ?? [])
       .map(normalize)
       .filter((r) => r.id);
-    return shape({ status: "ready", all, query: "" });
+    return shape({ status: "ready", all, query: currentQuery });
   } catch (e) {
-    return shape({ status: "error", all: [], error: String((e as Error)?.message ?? e) });
+    const errorKind = classifyError(e);
+    // Keep what was loaded on a refresh failure; clear it when access is gone.
+    const all = errorKind === "permission" ? [] : s.all ?? [];
+    return shape({ status: "error", all, query: currentQuery, errorKind });
   }
 }
 
@@ -97,17 +147,29 @@ const svc = defineService<PostsState, {
 }>("posts", {
   state: shape({ status: "loading" }),
   actions: {
-    load: async () => loadList(),
-    retry: async () => loadList(),
+    // `load` opens the screen, and the uncontrolled SearchField opens empty: start the
+    // query over too. A query typed while this fetch is in flight still wins.
+    load: async (s) => { currentQuery = ""; return loadList(s); },
+    retry: async (s) => loadList(s),
     // In-worker filter: swap what the bound `items` path holds. For datasets past
     // a few hundred rows, make this re-query the API instead (same descriptor).
     search: (s, arg) => {
       const query = queryFrom(arg);
+      currentQuery = query;
       return shape({ ...s, query, items: visible(s.all, query) });
     },
-    clear: (s) => shape({ ...s, query: "", items: s.all }),
+    clear: (s) => { currentQuery = ""; return shape({ ...s, query: "", items: s.all }); },
   },
 });
 
+// The SearchField is uncontrolled and shows empty on a cold boot, but the runtime restores the
+// persisted snapshot: last run's `query`, and the `items` and empty flags derived from it. Re-derive
+// them in place for an empty query before anything paints, or the list stays filtered by text the
+// field does not show until the first fetch settles.
+const booted = (svc as unknown as { getState?: () => Record<string, unknown> | undefined }).getState?.();
+if (booted && typeof booted === "object") {
+  Object.assign(booted, shape({ ...(booted as Partial<PostsState>), query: "", items: undefined }));
+}
+
 svc.load(); // fetch once at boot; searching never re-fetches
 export { svc };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/himalaya-cli",
-  "version": "0.1465.0",
+  "version": "0.1467.0",
   "type": "module",
   "description": "himi — the Himalaya authoring CLI. Build a Tier-5 content package on your own machine, push it to the production serve as a draft, preview it on web + Himi Player, and read worker logs back — the remote dev loop. Wraps @himalaya/serve-cli for transport.",
   "keywords": [
@@ -71,5 +71,5 @@
       "artifactId": "himalaya-cli"
     }
   },
-  "falconPackageHash": "19e0653508dd0a35a2413578ca22c6452471d39f3797b2cd827fb652"
+  "falconPackageHash": "7882aee1b35bad5d711c75125239b98cc49d21ee40dff33a6fda8b6b"
 }