@applicaster/zapp-react-native-utils 16.0.0-rc.9 → 16.0.0-rc.90

package/actionsExecutor/actions/refreshComponent.ts

@@ -0,0 +1,85 @@
+/// <reference types="@applicaster/applicaster-types" />
+import { appStore } from "@applicaster/zapp-react-native-redux/AppStore";
+import { loadPipesData } from "@applicaster/zapp-react-native-redux/ZappPipes";
+import {
+  getInflatedDataSourceUrl,
+  getSearchContext,
+} from "../../reactHooks/feed/useInflatedUrl";
+import { ActionResult } from "../ActionExecutor";
+import { ActionHandler, ActionExecutionContext } from "../types";
+import { createLogger } from "../../logger";
+
+const { log_info } = createLogger({
+  subsystem: "ActionExecutorContext",
+  category: "General",
+});
+
+/** Prefer component data.source, otherwise direct UIComponentContext parent. */
+function getComponentFeedData(component) {
+  if (component?.data?.source) {
+    return component.data;
+  }
+
+  if (component?.parent?.data?.source) {
+    return component.parent.data;
+  }
+
+  return null;
+}
+
+/**
+ * Refreshes a component's data by reloading its data source.
+ * Supports URL inflation with context variables.
+ */
+export const refreshComponentAction: ActionHandler = async (
+  _action,
+  context?: ActionExecutionContext
+): Promise<ActionResult> => {
+  const dispatch = appStore.getDispatch();
+
+  const componentData = getComponentFeedData(context?.component);
+
+  const source = componentData?.source;
+  const mapping = componentData?.mapping;
+
+  let dataSource = source;
+
+  if (source && mapping) {
+    dataSource =
+      getInflatedDataSourceUrl({
+        source,
+        contexts: {
+          entry: context?.screenEntry,
+          screen: context?.screenData,
+          search: getSearchContext(null, mapping),
+        },
+        mapping,
+      }) || source;
+  }
+
+  if (!dataSource) {
+    log_info("handleAction: refreshComponent skipped: no dataSource found");
+
+    return ActionResult.Success;
+  }
+
+  log_info(`handleAction: refreshComponent for dataSource:${dataSource}`, {
+    source,
+    inflatedUrl: dataSource,
+    mapping,
+    entryContextId: context?.entryContext?.id,
+    entryId: context?.entry?.id,
+  });
+
+  // TODO: In theory we should wait callback to complete, before completing the action, but now it's not needed
+  // TODO: handle focused item removal
+  dispatch(
+    loadPipesData(dataSource, {
+      silentRefresh: false,
+      clearCache: true,
+      riverId: context?.screenData?.id,
+    })
+  );
+
+  return ActionResult.Success;
+};

package/actionsExecutor/actions/screenSetVariable.ts

@@ -0,0 +1,35 @@
+/// <reference types="@applicaster/applicaster-types" />
+import { screenSetVariable } from "../ScreenActions";
+import { ActionResult } from "../ActionExecutor";
+import { ActionHandler, ActionExecutionContext } from "../types";
+
+/**
+ * Options for screenSetVariable action.
+ */
+export interface ScreenSetVariableOptions {
+  /** The key/namespace for storing the variable */
+  key: string;
+
+  /** Path to extract the value from entry */
+  selector?: string;
+}
+
+/**
+ * Sets a variable in screen state storage.
+ * The value is extracted from the entry using the selector option.
+ */
+export const screenSetVariableAction: ActionHandler<
+  ScreenSetVariableOptions
+> = async (action, context?: ActionExecutionContext): Promise<ActionResult> => {
+  const route = context?.screenRoute;
+  const screenStateStore = context?.screenStateStore;
+
+  await screenSetVariable(
+    route,
+    screenStateStore,
+    { entry: context?.entry, options: action.options },
+    action
+  );
+
+  return ActionResult.Success;
+};

package/actionsExecutor/actions/screenToggleFlag.ts

@@ -0,0 +1,38 @@
+/// <reference types="@applicaster/applicaster-types" />
+import { screenToggleFlag } from "../ScreenActions";
+import { ActionResult } from "../ActionExecutor";
+import { ActionHandler, ActionExecutionContext } from "../types";
+
+/**
+ * Options for screenToggleFlag action.
+ */
+export interface ScreenToggleFlagOptions {
+  /** The key/namespace for storing the flag */
+  key: string;
+
+  /** Path to extract the tag from entry (e.g., "extensions.tag") */
+  selector?: string;
+
+  /** Maximum number of items that can be selected */
+  max_items?: number;
+}
+
+/**
+ * Toggles a flag in screen state storage (adds or removes an item from a collection).
+ * Useful for screen-level multi-select functionality.
+ */
+export const screenToggleFlagAction: ActionHandler<
+  ScreenToggleFlagOptions
+> = async (action, context?: ActionExecutionContext): Promise<ActionResult> => {
+  const screenRoute = context?.screenRoute;
+  const screenStateStore = context?.screenStateStore;
+
+  await screenToggleFlag(
+    screenRoute,
+    screenStateStore,
+    { entry: context?.entry, options: action.options },
+    action
+  );
+
+  return ActionResult.Success;
+};

package/actionsExecutor/actions/sendCloudEvent.ts

@@ -0,0 +1,93 @@
+/// <reference types="@applicaster/applicaster-types" />
+import { createCloudEvent, sendCloudEvent } from "../../cloudEventsUtils";
+import {
+  EntryResolver,
+  resolveObjectValues,
+} from "../../appUtils/contextKeysManager/contextResolver";
+import { ActionResult } from "../ActionExecutor";
+import { ActionHandler, ActionExecutionContext } from "../types";
+import { createLogger } from "../../logger";
+
+const { log_info, log_error } = createLogger({
+  subsystem: "ActionExecutorContext",
+  category: "General",
+});
+
+/**
+ * Options for the sendCloudEvent action.
+ */
+export interface SendCloudEventOptions {
+  /** The cloud event type (defaults to "com.applicaster.selector.action.v1") */
+  type?: string;
+
+  /** The event data payload */
+  data?: Record<string, any>;
+
+  /** The event subject (defaults to entry.id) */
+  subject?: string;
+
+  /** The URL endpoint to send the event to */
+  url: string;
+
+  /** Whether to inflate data with context variables */
+  inflateData?: boolean;
+}
+
+/**
+ * Sends a cloud event to a remote endpoint.
+ * Supports data inflation using context variables from entry and screen.
+ */
+export const sendCloudEventAction: ActionHandler<
+  SendCloudEventOptions
+> = async (action, context?: ActionExecutionContext): Promise<ActionResult> => {
+  try {
+    const options = action.options as SendCloudEventOptions;
+
+    const entry = context?.entry || {};
+    const entryResolver = new EntryResolver(entry as ZappEntry);
+    const screenData = context?.screenStateStore?.getState?.()?.data || {};
+    const screenResolver = new EntryResolver(screenData as ZappEntry);
+
+    const data =
+      options?.data && options.inflateData
+        ? await resolveObjectValues(options.data, {
+            entry: entryResolver,
+            screen: screenResolver,
+          })
+        : options?.data || entry;
+
+    const cloudEvent = await createCloudEvent({
+      type: options.type || "com.applicaster.selector.action.v1",
+      data,
+      subject: options.subject || String((entry as ZappEntry)?.id || ""),
+    });
+
+    log_info("handleAction: sending sendCloudEvent to URL", {
+      url: options.url,
+      cloudEvent,
+    });
+
+    const { error, code } = await sendCloudEvent(cloudEvent, options.url);
+
+    log_info("handleAction: sendCloudEvent result", { code, error });
+
+    if (error) {
+      log_error("sendCloudEvent: error sending cloud event", { error });
+
+      return ActionResult.Error;
+    }
+
+    if (code && code >= 200 && code < 300 && !error) {
+      log_info("sendCloudEvent: cloud event sent successfully");
+
+      return ActionResult.Success;
+    }
+  } catch (error) {
+    log_error("sendCloudEvent: error sending cloud event", {
+      action,
+      error,
+    });
+  }
+
+  return ActionResult.Error;
+};

package/actionsExecutor/actions/sessionStorageRemove.ts

@@ -0,0 +1,19 @@
+/// <reference types="@applicaster/applicaster-types" />
+import { sessionStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/SessionStorage";
+import { batchRemoveFromStorage } from "../../zappFrameworkUtils/localStorageHelper";
+import { ActionResult } from "../ActionExecutor";
+import { ActionHandler } from "../types";
+import { StorageRemoveOptions } from "./localStorageRemove";
+
+/**
+ * Removes values from session storage organized by namespaces.
+ */
+export const sessionStorageRemoveAction: ActionHandler<
+  StorageRemoveOptions
+> = async (action): Promise<ActionResult> => {
+  const namespaces = action.options.content;
+  await batchRemoveFromStorage(namespaces, sessionStorage);
+  // TODO: Add support for ownershipKey and ownershipNamespace
+
+  return ActionResult.Success;
+};

package/actionsExecutor/actions/sessionStorageSet.ts

@@ -0,0 +1,20 @@
+/// <reference types="@applicaster/applicaster-types" />
+import { sessionStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/SessionStorage";
+import { batchSave } from "../../zappFrameworkUtils/localStorageHelper";
+import { ActionResult } from "../ActionExecutor";
+import { ActionHandler } from "../types";
+import { StorageSetOptions } from "./localStorageSet";
+
+/**
+ * Saves values to session storage organized by namespaces.
+ * The values persist only for the current app session.
+ */
+export const sessionStorageSetAction: ActionHandler<StorageSetOptions> = async (
+  action
+): Promise<ActionResult> => {
+  const namespaces = (action.options as StorageSetOptions).content;
+  await batchSave(namespaces, sessionStorage);
+  // TODO: Add support for ownershipKey and ownershipNamespace
+
+  return ActionResult.Success;
+};

package/actionsExecutor/actions/sessionStorageToggleFlag.ts

@@ -0,0 +1,15 @@
+/// <reference types="@applicaster/applicaster-types" />
+import { sessionStorageToggleFlag } from "../StorageActions";
+import { ActionResult } from "../ActionExecutor";
+import { ActionHandler, ActionExecutionContext } from "../types";
+import { StorageToggleFlagOptions } from "./localStorageToggleFlag";
+
+/**
+ * Toggles a flag in session storage (adds or removes an item from a collection).
+ * Values persist only for the current app session.
+ */
+export const sessionStorageToggleFlagAction: ActionHandler<
+  StorageToggleFlagOptions
+> = async (action, context?: ActionExecutionContext): Promise<ActionResult> => {
+  return await sessionStorageToggleFlag(context, action);
+};

package/actionsExecutor/actions/showAlert.ts

@@ -0,0 +1,51 @@
+/// <reference types="@applicaster/applicaster-types" />
+import { showAlertDialog } from "../../alertUtils";
+import { ActionResult } from "../ActionExecutor";
+import { ActionHandler } from "../types";
+import { createLogger } from "../../logger";
+
+const { log_info } = createLogger({
+  subsystem: "ActionExecutorContext",
+  category: "General",
+});
+
+/**
+ * Options for the showAlert action.
+ */
+export interface ShowAlertOptions {
+  /** Dialog title (required) */
+  title: string;
+
+  /** Dialog message */
+  message?: string;
+
+  /** Dismiss button text. Defaults to "OK" */
+  okButtonText?: string;
+}
+
+/**
+ * Tells the user something and waits for them to acknowledge it.
+ *
+ * One button, because there is nothing to decide. Use `confirmDialog` when the
+ * user is choosing between going on and backing out; a `confirmDialog` without
+ * a cancel label still renders two buttons, the second one blank.
+ *
+ * Always resolves to Success: dismissing a notice is not a cancellation, so the
+ * rest of the chain runs.
+ */
+export const showAlertAction: ActionHandler<ShowAlertOptions> = async (
+  action
+): Promise<ActionResult> => {
+  log_info("handleAction: showAlert event");
+
+  const options = action.options as ShowAlertOptions;
+
+  return new Promise<ActionResult>((resolve) => {
+    showAlertDialog({
+      title: options?.title,
+      message: options?.message,
+      okButtonText: options?.okButtonText || "OK",
+      completion: () => resolve(ActionResult.Success),
+    });
+  });
+};

package/actionsExecutor/actions/showToast.ts

@@ -0,0 +1,87 @@
+/// <reference types="@applicaster/applicaster-types" />
+import { ActionResult } from "../ActionExecutor";
+import { ActionHandler } from "../types";
+import { postEvent } from "../../reactHooks/useSubscriberFor";
+
+export const CONFIRMATION_TOAST_SOURCE = "confirmation";
+
+export const CONFIRMATION_TOAST_DEFAULT_TIMEOUT = 5000;
+
+/**
+ * Shows a mobile confirmation toast with Theme defaults from
+ * `Confirmation Toast / Message` in the base theme plugin.
+ *
+ * This action is confirmation-only by design: it always stamps
+ * `source: "confirmation"` (so Theme confirmation styles apply) and defaults
+ * `timeout` to 5000 ms. Non-confirmation toasts (e.g. Offline Experience)
+ * must post on the shared `"showToast"` event bus directly and omit `source`.
+ * Callers may override individual style fields; Theme supplies the rest.
+ *
+ * @example From React via ActionExecutorContext
+ * ```tsx
+ * import React, { useContext } from "react";
+ * import { ActionExecutorContext } from "@applicaster/zapp-react-native-utils/actionsExecutor/ActionExecutorContext";
+ *
+ * function QueueButton() {
+ *   const { handleAction } = useContext(ActionExecutorContext);
+ *
+ *   const onPress = () => {
+ *     void handleAction({
+ *       type: "showToast",
+ *       options: { message: "Added to queue" },
+ *     });
+ *   };
+ *
+ *   return <Button onPress={onPress} title="Add to queue" />;
+ * }
+ * ```
+ *
+ * @example From code via the actionExecutor singleton
+ * ```ts
+ * import { actionExecutor } from "@applicaster/zapp-react-native-utils/actionsExecutor/ActionExecutor";
+ *
+ * await actionExecutor.handleAction({
+ *   type: "showToast",
+ *   options: {
+ *     message: "Playlist created",
+ *     style: { backgroundColor: "#00AA55" }, // optional partial override
+ *   },
+ * });
+ * ```
+ *
+ * @example From entry / pipes actions JSON
+ * ```json
+ * {
+ *   "type": "showToast",
+ *   "options": {
+ *     "message": "Item removed from playlist"
+ *   }
+ * }
+ * ```
+ */
+export interface ShowToastActionOptions {
+  id?: string;
+  message?: string;
+  extraMessage?: string;
+  style?: any;
+  timeout?: number;
+}
+
+export const showToastAction: ActionHandler<ShowToastActionOptions> = async (
+  action
+): Promise<ActionResult> => {
+  const options = action?.options;
+
+  postEvent("showToast", [
+    {
+      id: options?.id,
+      message: options?.message,
+      extraMessage: options?.extraMessage,
+      style: options?.style,
+      timeout: options?.timeout ?? CONFIRMATION_TOAST_DEFAULT_TIMEOUT,
+      source: CONFIRMATION_TOAST_SOURCE,
+    },
+  ]);
+
+  return ActionResult.Success;
+};

package/actionsExecutor/actions/switchLayout.ts

@@ -0,0 +1,40 @@
+/// <reference types="@applicaster/applicaster-types" />
+import { localStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/LocalStorage";
+import * as QuickBrickManager from "@applicaster/zapp-react-native-bridge/QuickBrick";
+import { QUICK_BRICK_EVENTS } from "@applicaster/zapp-react-native-bridge/QuickBrick";
+import { ACTIVE_LAYOUT_ID_STORAGE_KEY } from "@applicaster/quick-brick-core/App/remoteContextReloader/consts";
+import { ActionResult } from "../ActionExecutor";
+import { ActionHandler } from "../types";
+import { createLogger } from "../../logger";
+
+const { log_info } = createLogger({
+  subsystem: "ActionExecutorContext",
+  category: "General",
+});
+
+/**
+ * Options for the switchLayout action.
+ */
+export interface SwitchLayoutOptions {
+  /** The ID of the layout to switch to */
+  layoutId: string;
+}
+
+/**
+ * Switches the active layout and triggers an app reload.
+ * Saves the new layout ID to local storage before reloading.
+ */
+export const switchLayoutAction: ActionHandler<SwitchLayoutOptions> = async (
+  action
+): Promise<ActionResult> => {
+  log_info("handleAction: switchLayout event");
+
+  await localStorage.setItem(
+    ACTIVE_LAYOUT_ID_STORAGE_KEY,
+    action.options.layoutId
+  );
+
+  QuickBrickManager.sendQuickBrickEvent(QUICK_BRICK_EVENTS.FORCE_APP_RELOAD);
+
+  return ActionResult.Success;
+};

package/actionsExecutor/consts.ts

@@ -2,3 +2,30 @@ export const TOGGLE_FLAG_MAX_ITEMS_REACHED_EVENT =
   "action.localStorageToggleFlag.maxItemsReached";
 
 export const ACTION_EXECUTOR_EVENT_SOURCE = "ActionExecutor";
+
+export const ACTION_TYPES = {
+  OPEN_BOTTOM_SHEET: "openBottomSheet",
+  DISMISS_BOTTOM_SHEET: "dismissBottomSheet",
+  PRESENT_SUB_MENU: "presentSubMenu",
+  SEND_CLOUD_EVENT: "sendCloudEvent",
+  NAVIGATE_TO_SCREEN: "navigateToScreen",
+  PRESENT_SCREEN: "presentScreen",
+  GO_BACK: "goBack",
+  GO_HOME: "goHome",
+  SHOW_TOAST: "showToast",
+  LOCAL_STORAGE_SET: "localStorageSet",
+  LOCAL_STORAGE_REMOVE: "localStorageRemove",
+  LOCAL_STORAGE_TOGGLE_FLAG: "localStorageToggleFlag",
+  SESSION_STORAGE_SET: "sessionStorageSet",
+  SESSION_STORAGE_REMOVE: "sessionStorageRemove",
+  SESSION_STORAGE_TOGGLE_FLAG: "sessionStorageToggleFlag",
+  REFRESH_COMPONENT: "refreshComponent",
+  SWITCH_LAYOUT: "switchLayout",
+  APP_RESTART: "appRestart",
+  CONFIRM_DIALOG: "confirmDialog",
+  SHOW_ALERT: "showAlert",
+  SCREEN_SET_VARIABLE: "screenSetVariable",
+  SCREEN_TOGGLE_FLAG: "screenToggleFlag",
+} as const;
+
+export type KnownActionType = (typeof ACTION_TYPES)[keyof typeof ACTION_TYPES];

package/actionsExecutor/feedDecorator.ts

@@ -159,13 +159,13 @@ export const decorateFeed = (feed: ZappFeed) => {
 
   const decoratedFeed = R.clone(feed);
 
-  const isSingleSelect =
-    (feed.extensions?.preference_editor_options?.select_mode ||
-      feed.extensions?.behavior?.select_mode) === "single";
+  const selectMode =
+    feed.extensions?.preference_editor_options?.select_mode ||
+    feed.extensions?.behavior?.select_mode;
 
-  if (isSingleSelect) {
+  if (selectMode === "single") {
     return makeSingleSelect(feed, key, decoratedFeed);
-  } else {
-    return makeMultiSelect(feed, key, decoratedFeed);
   }
+
+  return makeMultiSelect(feed, key, decoratedFeed);
 };

package/actionsExecutor/types.ts

@@ -0,0 +1,59 @@
+/// <reference types="@applicaster/applicaster-types" />
+import { ActionResult } from "./ActionExecutor";
+import { useScreenStateStore } from "../reactHooks/navigation/useScreenStateStore";
+
+/**
+ * Base context object passed to action handlers during execution.
+ * Contains references to the current entry, screen, and other execution state.
+ */
+export interface ActionExecutionContext {
+  /** The entry associated with this action (e.g., the item that was tapped) */
+  entry?: ZappEntry;
+
+  /** The current screen/river data */
+  screenData?: ZappRiver;
+
+  /** The entry that defines the screen (if screen was opened from an entry) */
+  screenEntry?: ZappEntry;
+
+  /** The UI component that triggered the action.
+   * From UIComponentContext as `{ ...component, parent }`.
+   */
+  component?: ZappUIComponent & { parent?: ZappUIComponent };
+
+  /** The route identifier for the current screen */
+  screenRoute?: string;
+
+  /** The screen state store for managing screen-level state (Zustand store) */
+  screenStateStore?: ReturnType<typeof useScreenStateStore>;
+
+  /** Context entry for additional data */
+  entryContext?: ZappEntry;
+
+  /** Callback function for action completion */
+  callback?: (result: { success: boolean; error: any; abort: boolean }) => void;
+
+  screenState?: Record<any, any>;
+}
+
+/**
+ * Type for action handler functions.
+ * Handlers receive the action (which may have typed options) and execution context.
+ *
+ * @template _TOptions - Optional type hint for the action's options object (for documentation/intellisense)
+ * @param action - The action to execute
+ * @param context - The execution context
+ * @returns A promise that resolves to the action result
+ */
+export type ActionHandler<_TOptions = any> = (
+  action: ActionType,
+  context?: ActionExecutionContext
+) => Promise<ActionResult>;
+
+/**
+ * Factory function that creates an action handler.
+ * Used for actions that need to capture dependencies at registration time.
+ */
+export type ActionHandlerFactory<_TOptions = any> = (
+  ...dependencies: any[]
+) => ActionHandler<_TOptions>;

package/analyticsUtils/AnalyticsEvents/sendMenuClickEvent.ts

@@ -6,9 +6,9 @@ import { postAnalyticEvent } from "../manager";
 import { ANALYTICS_CORE_EVENTS } from "../events";
 
 type AnalyticsDefaultHelperProperties = {
-  analyticsScreenData: AnalyticsScreenProperties;
+  analyticsScreenData?: AnalyticsScreenProperties;
   extraProps: any;
-  props;
+  props?: any;
 };
 
 export const sendMenuClickEvent = ({

package/analyticsUtils/PlayerAnalyticsManager.ts

@@ -8,7 +8,7 @@ import {
 } from "../appUtils/playerManager";
 import { Player } from "../appUtils/playerManager/player";
 import { AnalyticPlayerListener } from "./AnalyticPlayerListener";
-import { PlayerRole } from "../appUtils/playerManager/conts";
+import { PlayerRole } from "../appUtils/playerManager/const";
 
 enum PlayerAnalyticsTrackerType {
   PlayerAnalyticsTracker = "PlayerAnalyticsTracker",
@@ -23,6 +23,15 @@ class PlayerAnalyticsTrackerFactory {
         return new PlayerAnalyticsTracker();
     }
   }
+
+  onPlayerRegistered(tracker: PlayerAnalyticsTrackerI, player: Player) {
+    tracker.setPlayer(player);
+    tracker.onPlayerPresented();
+  }
+
+  onPlayerUnRegistered(tracker?: PlayerAnalyticsTrackerI) {
+    tracker?.onPlayerClosed();
+  }
 }
 
 export class PlayerAnalyticsManager implements PlayerLifecycleListener {
@@ -70,7 +79,7 @@ export class PlayerAnalyticsManager implements PlayerLifecycleListener {
     }
 
     const tracker = this.getTracker(player.playerId);
-    tracker.setPlayer(player);
+    this.trackerFactory.onPlayerRegistered(tracker, player);
 
     const analyticsListener = new AnalyticPlayerListener({
       analyticsTracker: tracker,
@@ -84,6 +93,7 @@ export class PlayerAnalyticsManager implements PlayerLifecycleListener {
   };
 
   onUnRegistered = (player: Player) => {
+    this.trackerFactory.onPlayerUnRegistered(this.trackers[player.playerId]);
     player.removeListener(AnalyticPlayerListener.analyticsListenerID);
     delete this.trackers[player.playerId];
   };