@applicaster/zapp-react-native-utils 16.0.0-rc.72 → 16.0.0-rc.74

package/manifestUtils/_internals/index.js

@@ -135,7 +135,8 @@ function generateFieldsFromDefaults(label, defaults, fields) {
 function generateFieldsFromDefaultsWithoutPrefixedLabel(
   label,
   defaults,
-  fields
+  fields,
+  { withStyle = false } = {}
 ) {
   const keyPrefix = toSnakeCase(label);
 
@@ -151,7 +152,9 @@ function generateFieldsFromDefaultsWithoutPrefixedLabel(
         const generatedField = {
           ...fieldProps,
           label: capitalizeFirstLetter(field.suffix),
-          key: `${keyPrefix}_${toSnakeCase(field.suffix)}`,
+          key: withStyle
+            ? `${keyPrefix}_style_${toSnakeCase(field.suffix)}`
+            : `${keyPrefix}_${toSnakeCase(field.suffix)}`,
           initial_value: R.when(R.is(Array), R.head)(initialValue),
         };
 
@@ -164,7 +167,9 @@ function generateFieldsFromDefaultsWithoutPrefixedLabel(
             const section = condition.section ? `${condition.section}/` : "";
 
             return {
-              key: `${section}${keyPrefix}_${toSnakeCase(condition.key)}`,
+              key: withStyle
+                ? `${section}${keyPrefix}_style_${toSnakeCase(condition.key)}`
+                : `${section}${keyPrefix}_${toSnakeCase(condition.key)}`,
               condition_value: condition.value,
             };
           });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/zapp-react-native-utils",
-  "version": "16.0.0-rc.72",
+  "version": "16.0.0-rc.74",
   "description": "Applicaster Zapp React Native utilities package",
   "main": "index.js",
   "types": "index.d.ts",
@@ -27,7 +27,7 @@
   },
   "homepage": "https://github.com/applicaster/quickbrick#readme",
   "dependencies": {
-    "@applicaster/applicaster-types": "16.0.0-rc.72",
+    "@applicaster/applicaster-types": "16.0.0-rc.74",
     "buffer": "^5.2.1",
     "camelize": "^1.0.0",
     "dayjs": "^1.11.10",

package/reactHooks/actions/index.ts

@@ -87,7 +87,31 @@ export function useEntryActionState(
   useEffect(() => {
     if (!action) return undefined;
 
-    const subscription = observeEntryState(action, entry).subscribe(setState);
+    // An action's stream is third-party code. Subscribing with only a `next`
+    // handler lets RxJS rethrow an error notification asynchronously, where no
+    // error boundary catches it - one plugin faulting would take the app down
+    // rather than this one button. The button keeps its last known state.
+    let subscription;
+
+    try {
+      subscription = observeEntryState(action, entry).subscribe({
+        next: setState,
+        error: (error) =>
+          logger.warning({
+            message:
+              "useEntryActionState: the action's state stream failed - the button keeps its last state",
+            data: { entryId, error },
+          }),
+      });
+    } catch (error) {
+      logger.warning({
+        message:
+          "useEntryActionState: could not observe the action - the button keeps its initial state",
+        data: { entryId, error },
+      });
+
+      return undefined;
+    }
 
     return () => subscription.unsubscribe();
     // eslint-disable-next-line @wogns3623/better-exhaustive-deps/exhaustive-deps

package/uiActionsRegistrator/index.ts

@@ -1,4 +1,6 @@
 export {
+  canRenderActionIcon,
+  resolveActionAsset,
   isActionAvailableFor,
   observeEntryState,
   uiActionsRegistry,

package/uiActionsRegistrator/registry.ts

@@ -1,4 +1,5 @@
 /* eslint-disable no-dupe-class-members */
+import type { ComponentType } from "react";
 import { Observable } from "rxjs";
 import { createLogger } from "../logger";
 
@@ -119,12 +120,101 @@ export function isActionAvailableFor(
   action: RegisteredActionValue | undefined,
   entry: ZappEntry | ZappFeed
 ): boolean {
-  const predicate =
-    action?.isSupportDownloads ??
-    action?.isActionSupported ??
-    action?.isActionAvailable;
+  // The first name the action defines *as a function* answers. Nullish
+  // coalescing would let a plugin shipping one of these as a plain flag
+  // short-circuit the chain and mask a real predicate behind it.
+  const predicate = [
+    action?.isSupportDownloads,
+    action?.isActionSupported,
+    action?.isActionAvailable,
+  ].find((candidate) => typeof candidate === "function");
 
-  return typeof predicate === "function" ? Boolean(predicate(entry)) : true;
+  if (!predicate) {
+    return true;
+  }
+
+  try {
+    return Boolean(predicate(entry));
+  } catch (error) {
+    // Third-party code, called during render. Showing the action is the
+    // recoverable answer: a button that does nothing beats a screen that does
+    // not render.
+    log_warning(
+      "isActionAvailableFor: availability check threw - the action is shown",
+      { entryId: (entry as ZappEntry)?.id, error }
+    );
+
+    return true;
+  }
+}
+
+/** How an action's asset should be drawn, or `null` if it cannot be. */
+export type ResolvedActionAsset =
+  | { uri: string }
+  | { Component: ComponentType<any> }
+  | null;
+
+/**
+ * Interprets `CellActionEntryState["asset"]`.
+ *
+ * It is either something an image can take - a URI, or a per-flavour array -
+ * or a component that draws itself. A plain object is neither: a locale or
+ * state map arrives that way, and handing one to JSX throws "Element type is
+ * invalid".
+ *
+ * A React *element* carries the same `$$typeof` marker as a `memo`,
+ * `forwardRef` or `lazy` result, so `asset: <Icon/>` where `asset: Icon` was
+ * meant would pass a naive check and throw exactly that. Elements are told
+ * apart by carrying `props`.
+ *
+ * One function so that "can this draw?" and "draw it" cannot disagree.
+ */
+export function resolveActionAsset(asset: unknown): ResolvedActionAsset {
+  if (typeof asset === "string") {
+    return asset.length > 0 ? { uri: asset } : null;
+  }
+
+  if (Array.isArray(asset)) {
+    const first = asset.find(
+      (candidate) => typeof candidate === "string" && candidate.length > 0
+    );
+
+    return first ? { uri: first as string } : null;
+  }
+
+  if (typeof asset === "function") {
+    return { Component: asset as ComponentType<any> };
+  }
+
+  if (
+    typeof asset === "object" &&
+    asset !== null &&
+    "$$typeof" in asset &&
+    !("props" in asset)
+  ) {
+    return { Component: asset as ComponentType<any> };
+  }
+
+  return null;
+}
+
+/**
+ * Whether the action has something an icon-only button can actually draw.
+ *
+ * An overlay button is an icon and nothing else, so an action whose state
+ * carries no usable asset renders as nothing at all - legal for an entry action
+ * declared with a title and no `iconURL`. Surfaces that must keep an action
+ * reachable ask this before putting it somewhere it can only appear as an icon.
+ */
+export function canRenderActionIcon(
+  action: RegisteredActionValue | undefined,
+  entry: ZappEntry | ZappFeed
+): boolean {
+  try {
+    return resolveActionAsset(action?.initialEntryState?.(entry)?.asset) !== null; // prettier-ignore
+  } catch {
+    return false;
+  }
 }
 
 class UIActionsRegistry {