@applicaster/zapp-react-native-utils 16.0.0-alpha.8716141508 → 16.0.0-alpha.9024462102

package/entryActions/buildEntryActions.ts

@@ -0,0 +1,167 @@
+/// <reference types="@applicaster/applicaster-types" />
+import { createLogger } from "../logger";
+import { ActionExecutionContext } from "../actionsExecutor/types";
+import { RegisteredAction } from "../uiActionsRegistrator";
+
+import {
+  resolveButtonAsset,
+  resolveButtonLabel,
+  resolveExplicitLabel,
+} from "./aliasPresentation";
+import { EntryAction, EntryActionDeps } from "./types";
+
+const { log_info, log_warning, log_error } = createLogger({
+  subsystem: "EntryActions",
+  category: "EntryAction",
+});
+
+const ENTRY_ACTION_IDENTIFIER_PREFIX = "entry_action";
+
+/** True for actions inflated from `entry.extensions.entry_action`. */
+export function isEntryAction(item: RegisteredAction): boolean {
+  return item?.source === "entry";
+}
+
+function isValidEntryAction(value: unknown): value is EntryAction {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+
+  const { button, actions } = value as EntryAction;
+
+  return (
+    (typeof button?.title === "string" ||
+      typeof button?.label === "string" ||
+      typeof button?.alias === "string") &&
+    Array.isArray(actions)
+  );
+}
+
+function createEntryAction(
+  entryAction: EntryAction,
+  index: number,
+  entry: ZappEntry | ZappFeed,
+  deps: EntryActionDeps
+): RegisteredAction {
+  const { button, actions, dismiss_on_action } = entryAction;
+
+  const identifier = `${ENTRY_ACTION_IDENTIFIER_PREFIX}_${index}`;
+  const primaryAction = actions.length > 0 ? actions[0] : null;
+
+  const actionState = primaryAction
+    ? deps.actionExecutor?.getActionState?.(primaryAction.type, entry)
+    : null;
+
+  // An explicit title/label outranks the executor's action state; the
+  // alias-derived defaults only fill in when neither produced anything.
+  const label: CellActionEntryState["label"] =
+    resolveExplicitLabel(button) ||
+    actionState?.label ||
+    resolveButtonLabel(button, deps.aliasPresentation);
+
+  const asset: CellActionEntryState["asset"] =
+    button?.iconURL ||
+    actionState?.asset ||
+    resolveButtonAsset(button, deps.aliasPresentation);
+
+  const initialState = { state: 0, label, asset };
+
+  return {
+    identifier,
+    source: "entry",
+    action: {
+      initialEntryState: () => initialState,
+      invokeAction: async (
+        invokedEntry: ZappEntry,
+        options: InvokeArgsOptions = {}
+      ) => {
+        if (dismiss_on_action === true) {
+          options.dismiss?.();
+        }
+
+        log_info(
+          `invokeAction: entry action "${identifier}" triggered for entry "${invokedEntry?.id}"`,
+          { identifier, entryId: invokedEntry?.id, actionCount: actions.length }
+        );
+
+        // Both of these leave the user with a button that does nothing when
+        // tapped, and neither throws, so they would otherwise be invisible.
+        if (actions.length === 0) {
+          log_warning(
+            `invokeAction: entry action "${identifier}" on entry "${invokedEntry?.id}" declares no actions - the tap does nothing`,
+            { identifier, entryId: invokedEntry?.id }
+          );
+        }
+
+        if (typeof deps.actionExecutor?.handleActions !== "function") {
+          log_warning(
+            `invokeAction: no action executor available for entry action "${identifier}" - the tap does nothing`,
+            { identifier, entryId: invokedEntry?.id }
+          );
+        }
+
+        try {
+          await deps.actionExecutor?.handleActions(actions, {
+            entry: invokedEntry,
+            entryContext: invokedEntry,
+            ...deps.actionContext,
+            ...(options.component ? { component: options.component } : {}),
+          } as ActionExecutionContext);
+        } catch (error) {
+          log_error(
+            `invokeAction: entry action "${identifier}" failed for entry "${invokedEntry?.id}"`,
+            {
+              identifier,
+              entryId: invokedEntry?.id,
+              // Types only - the action payloads are backend supplied and may
+              // carry user data.
+              actionTypes: actions.map((action) => action?.type),
+              error,
+            }
+          );
+        }
+      },
+    },
+  };
+}
+
+/**
+ * Builds the list of actions declared on an entry via
+ * `entry.extensions.entry_action`.
+ */
+export function buildEntryActions(
+  entry: ZappEntry | ZappFeed,
+  deps: EntryActionDeps
+): RegisteredAction[] {
+  const entryId = (entry as ZappEntry)?.id;
+  const raw = (entry as any)?.extensions?.entry_action;
+
+  // Most entries simply declare no actions. This provider is resolved for
+  // every entry on every render, so saying so would drown everything else.
+  if (raw === undefined || raw === null) {
+    return [];
+  }
+
+  if (!Array.isArray(raw)) {
+    log_warning(
+      `buildEntryActions: entry "${entryId}" has extensions.entry_action of type ${typeof raw} instead of an array - no entry actions will be shown`,
+      { entryId, receivedType: typeof raw }
+    );
+
+    return [];
+  }
+
+  const valid = raw.filter(isValidEntryAction);
+  const invalid = raw.length - valid.length;
+
+  if (invalid > 0) {
+    log_warning(
+      `buildEntryActions: ${invalid} invalid entry action(s) skipped for entry "${entryId}"`,
+      { entryId, total: raw.length, invalid }
+    );
+  }
+
+  return valid.map((entryAction, index) =>
+    createEntryAction(entryAction, index, entry, deps)
+  );
+}

package/entryActions/index.ts

@@ -0,0 +1,15 @@
+export { buildEntryActions, isEntryAction } from "./buildEntryActions";
+
+export {
+  resolveButtonAsset,
+  resolveButtonLabel,
+  resolveExplicitLabel,
+} from "./aliasPresentation";
+
+export type {
+  EntryAction,
+  EntryActionDeps,
+  EntryActionExecutionContext,
+} from "./types";
+
+export type { AliasPresentation } from "./aliasPresentation";

package/entryActions/types.ts

@@ -0,0 +1,39 @@
+/// <reference types="@applicaster/applicaster-types" />
+import type { ActionExecutorContextType } from "../actionsExecutor/ActionExecutorContext";
+import type { AliasPresentation } from "./aliasPresentation";
+
+/**
+ * A single action declared by the backend on an entry, under
+ * `entry.extensions.entry_action`.
+ */
+export type EntryAction = {
+  button: {
+    title?: string;
+    label?: string;
+    alias?: string;
+    iconURL?: string;
+  };
+  actions: ZappActionType[];
+  dismiss_on_action?: boolean;
+};
+
+/**
+ * Everything `buildEntryActions` needs from the surrounding React tree in order
+ * to execute an entry action. Supplied lazily so the registered provider always
+ * reads the freshest screen context.
+ */
+export type EntryActionDeps = {
+  actionExecutor: ActionExecutorContextType;
+  actionContext: EntryActionExecutionContext;
+  /** App-supplied labels/icons for backend aliases; defaults are used without it. */
+  aliasPresentation?: AliasPresentation;
+};
+
+/** The screen the action is executed against, spread into the execution context. */
+export type EntryActionExecutionContext = {
+  screenData?: unknown;
+  screenState?: unknown;
+  screenRoute?: string;
+  screenStateStore?: unknown;
+  screenEntry?: unknown;
+};

package/manifestUtils/__tests__/player.audioControls.test.js

@@ -0,0 +1,158 @@
+const { player } = require("../defaultManifestConfigurations/player");
+
+const manifestFor = (platform) => player({ platform, version: "0.0.0" });
+
+const findGroup = (manifest, label) =>
+  manifest.styles.fields.find((group) => group.group && group.label === label);
+
+const findFieldInGroup = (manifest, label, key) =>
+  findGroup(manifest, label)?.fields?.find((field) => field.key === key);
+
+const findLocalization = (manifest, key) =>
+  manifest.localizations.fields.find((field) => field.key === key);
+
+describe("player manifest — audio playlist controls", () => {
+  const manifest = manifestFor("ios_for_quickbrick");
+
+  describe("Player Controls Layout", () => {
+    const field = () =>
+      findFieldInGroup(manifest, "Audio Player", "player_controls_layout");
+
+    it("is declared in the Audio Player group", () => {
+      expect(field()).toBeDefined();
+    });
+
+    it("is a select defaulting to the existing controls", () => {
+      expect(field().type).toBe("select");
+      expect(field().initial_value).toBe("playback_speed_and_sleep_timer");
+    });
+
+    it("only shows when the audio player layout is in use", () => {
+      expect(field()).toMatchObject({
+        rules: "conditional",
+        conditional_fields: [
+          { key: "styles/full_screen_audio_player", condition_value: true },
+        ],
+      });
+    });
+
+    it("offers exactly the two documented options", () => {
+      expect(field().options).toEqual([
+        {
+          text: "Playback Speed & Sleep Timer (Default)",
+          value: "playback_speed_and_sleep_timer",
+        },
+        {
+          text: "Playlist Controls (Previous & Next)",
+          value: "playlist_controls",
+        },
+      ]);
+    });
+  });
+
+  describe("control icons", () => {
+    it.each(["previous_track", "next_track"])(
+      "declares %s as an uploader",
+      (key) => {
+        expect(findFieldInGroup(manifest, "Assets", key)).toMatchObject({
+          key,
+          type: "uploader",
+        });
+      }
+    );
+
+    it.each(["previous_track", "next_track"])(
+      "only shows %s when the playlist controls layout is selected",
+      (key) => {
+        expect(findFieldInGroup(manifest, "Assets", key)).toMatchObject({
+          rules: "conditional",
+          conditional_fields: [
+            {
+              key: "styles/player_controls_layout",
+              condition_value: "playlist_controls",
+            },
+          ],
+        });
+      }
+    );
+
+    it.each([
+      "speed_0_8",
+      "speed_1",
+      "speed_1_2",
+      "speed_1_5",
+      "speed_2",
+      "sleep_timer",
+      "sleep_timer_active",
+    ])(
+      "only shows %s when the playback speed and sleep timer layout is selected",
+      (key) => {
+        expect(findFieldInGroup(manifest, "Assets", key)).toMatchObject({
+          rules: "conditional",
+          conditional_fields: [
+            {
+              key: "styles/player_controls_layout",
+              condition_value: "playback_speed_and_sleep_timer",
+            },
+          ],
+        });
+      }
+    );
+  });
+
+  describe("accessibility strings", () => {
+    it.each([
+      "accessibility_previous_track_label",
+      "accessibility_previous_track_hint",
+      "accessibility_next_track_label",
+      "accessibility_next_track_hint",
+    ])("declares %s with a default", (key) => {
+      expect(findLocalization(manifest, key)).toMatchObject({
+        type: "text_input",
+      });
+
+      expect(findLocalization(manifest, key).initial_value).toBeTruthy();
+    });
+  });
+
+  describe("tv platforms", () => {
+    // The audio player layout is mobile only, so nothing this feature adds —
+    // including its screen reader strings — belongs in a tv manifest.
+    it.each(["tvos_for_quickbrick", "android_tv_for_quickbrick", "lg_tv"])(
+      "adds no audio controls layout field on %s",
+      (platform) => {
+        expect(
+          findFieldInGroup(
+            manifestFor(platform),
+            "Audio Player",
+            "player_controls_layout"
+          )
+        ).toBeUndefined();
+      }
+    );
+
+    it.each([
+      "accessibility_previous_track_label",
+      "accessibility_previous_track_hint",
+      "accessibility_next_track_label",
+      "accessibility_next_track_hint",
+    ])("does not declare %s on tv", (key) => {
+      expect(
+        findLocalization(manifestFor("tvos_for_quickbrick"), key)
+      ).toBeUndefined();
+    });
+
+    it("still declares the tv-only localizations", () => {
+      expect(
+        findLocalization(
+          manifestFor("tvos_for_quickbrick"),
+          "back_to_live_label"
+        )
+      ).toBeDefined();
+
+      expect(
+        findLocalization(manifestFor("tvos_for_quickbrick"), "start_over_label")
+      ).toBeDefined();
+    });
+  });
+});

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/manifestUtils/defaultManifestConfigurations/generalContent.js

@@ -12,6 +12,12 @@ const generalContent = () => ({
         label: "Navigation Bar",
         placeholder: "Choose Nav Bar",
       },
+      {
+        key: "hide_menu",
+        type: "switch",
+        label: "Hide Menu",
+        initial_value: false,
+      },
     ],
   },
   styles: {