@applicaster/zapp-react-native-utils 14.0.0-alpha.8419134002 → 14.0.0-alpha.9848043301

package/actionsExecutor/ActionExecutorContext.tsx

@@ -25,7 +25,7 @@ import {
   resolveObjectValues,
 } from "../appUtils/contextKeysManager/contextResolver";
 import { useNavigation } from "../reactHooks";
-import { get } from "../utils";
+import { get } from "lodash";
 
 import {
   useContentTypes,

package/analyticsUtils/AnalyticsEvents/helper.ts

@@ -4,12 +4,9 @@ import {
   ANALYTICS_COMPONENT_EVENTS,
   ANALYTICS_CORE_EVENTS,
   ANALYTICS_ENTRY_EVENTS,
-  ANALYTICS_PREFERENCES_EVENTS,
   DOWNLOADS_EVENTS,
 } from "../events";
 import { isEmptyOrNil } from "../../cellUtils";
-import { get } from "lodash";
-import { StorageMultiSelectProvider } from "@applicaster/zapp-react-native-bridge/ZappStorage/StorageMultiSelectProvider";
 
 export enum OfflineItemState {
   notExist = "NOT_EXISTS",
@@ -105,84 +102,6 @@ export function eventForComponent(
   return analyticsProps;
 }
 
-/**
- * Checks if an item is currently selected in localStorage based on its actions
- * @param item - The item to check
- * @returns boolean indicating if the item is currently selected
- */
-function isItemPreviouslySelected(item: any): boolean {
-  const actions = item?.extensions?.tap_actions?.actions;
-
-  if (!actions) {
-    return false;
-  }
-
-  const localStorageAction = actions.find(
-    (action) => action?.type === "localStorageToggleFlag"
-  );
-
-  if (!localStorageAction?.options?.key) {
-    return false;
-  }
-
-  const keyNamespace = localStorageAction.options.key;
-
-  const tag = localStorageAction.options?.selector
-    ? get(item, localStorageAction.options.selector)
-    : (item.extensions?.tag ?? item.id);
-
-  if (!tag) {
-    return false;
-  }
-
-  try {
-    const multiSelectProvider =
-      StorageMultiSelectProvider.getProvider(keyNamespace);
-
-    const selectedItems = multiSelectProvider.getSelectedItems();
-
-    return selectedItems.includes(tag);
-  } catch (error) {
-    return false;
-  }
-}
-
-export function getLocalStorageSetPayload(extraProps) {
-  const { item } = extraProps;
-
-  const hasLocalStorageSetAction = item?.extensions?.tap_actions?.actions?.some(
-    (action) => action?.type === "localStorageSet"
-  );
-
-  if (!hasLocalStorageSetAction) {
-    return null;
-  }
-
-  return {
-    [ANALYTICS_PREFERENCES_EVENTS.ITEM_SELECTED_STATUS]: true,
-  };
-}
-
-export function getLocalStorageToggleFlagPayload(extraProps) {
-  const { item } = extraProps;
-
-  const hasLocalStorageToggleAction =
-    item?.extensions?.tap_actions?.actions?.some(
-      (action) => action?.type === "localStorageToggleFlag"
-    );
-
-  if (!hasLocalStorageToggleAction) {
-    return null;
-  }
-
-  const previouslySelected = isItemPreviouslySelected(item);
-
-  return {
-    [ANALYTICS_PREFERENCES_EVENTS.ITEM_SELECTED_STATUS]: !previouslySelected,
-    [ANALYTICS_PREFERENCES_EVENTS.PREVIOUS_SELECTED_STATE]: previouslySelected,
-  };
-}
-
 export function playEventForType(item) {
   const itemType = item?.type && item.type?.value;
 

package/analyticsUtils/AnalyticsEvents/sendOnClickEvent.ts

@@ -1,13 +1,13 @@
 import { log_error, log_debug } from "../logger";
-import { ANALYTICS_CORE_EVENTS, ACTION_TYPE } from "../events";
+
+import { ANALYTICS_CORE_EVENTS } from "../events";
+
 import { postAnalyticEvent } from "../manager";
 import {
   replaceAnalyticsPropsNils,
   eventForEntry,
   eventForComponent,
   extensionsEvents,
-  getLocalStorageSetPayload,
-  getLocalStorageToggleFlagPayload,
 } from "./helper";
 
 declare type AnalyticsDefaultHelperProperties = {
@@ -26,16 +26,7 @@ export const sendOnClickEvent = ({
   const castedExtraProps: ExtraProps = extraProps;
   const componentData = component || extraProps.component;
   const data = zappPipesData || extraProps.zappPipesData;
-
-  const actionCellPayload =
-    extraProps?.item?.type?.value === ACTION_TYPE
-      ? getLocalStorageSetPayload(extraProps) ||
-        getLocalStorageToggleFlagPayload(extraProps)
-      : null;
-
-  const eventName = actionCellPayload
-    ? ANALYTICS_CORE_EVENTS.TAP_SELECTABLE_CELL
-    : ANALYTICS_CORE_EVENTS.TAP_CELL;
+  const eventName = ANALYTICS_CORE_EVENTS.TAP_CELL;
 
   if (!analyticsScreenData) {
     log_error(
@@ -53,7 +44,6 @@ export const sendOnClickEvent = ({
     ...replaceAnalyticsPropsNils({
       ...analyticsScreenData,
     }),
-    ...actionCellPayload,
   };
 
   if (analyticsCustomProperties) {

package/analyticsUtils/__tests__/analyticsUtils.test.js

@@ -3,22 +3,8 @@ import { ANALYTICS_CORE_EVENTS } from "../events";
 
 jest.mock("@applicaster/zapp-react-native-utils/reactUtils", () => ({
   isWeb: jest.fn(),
-  platformSelect: jest.fn(
-    (options) => options.android || options.ios || options.web
-  ),
 }));
 
-jest.mock(
-  "@applicaster/zapp-react-native-bridge/ZappStorage/StorageMultiSelectProvider",
-  () => ({
-    StorageMultiSelectProvider: {
-      getProvider: jest.fn(() => ({
-        getSelectedItems: jest.fn(() => []),
-      })),
-    },
-  })
-);
-
 const mock_postAnalyticEvent = jest.fn();
 const mock_startAnalyticsTimedEvent = jest.fn();
 const mock_endAnalyticsTimedEvent = jest.fn();

package/analyticsUtils/events.ts

@@ -17,11 +17,8 @@ export const SCREEN_VIEW_EVENTS = {
   TIME_ON_SCREEN: "time_on_screen",
 };
 
-export const ACTION_TYPE = "action";
-
 export const TAPPING_EVENTS = {
   TAP_CELL: "tap_cell",
-  TAP_SELECTABLE_CELL: "tap_selectable_cell",
   TAP_MENU: "tap_menu",
   TAP_NAVBAR_BACK_BUTTON: "tap_navbar_back_button",
 };
@@ -102,11 +99,6 @@ export const ANALYTICS_COMPONENT_EVENTS = {
   COMPONENT_SOURCE: "component_source",
 };
 
-export const ANALYTICS_PREFERENCES_EVENTS = {
-  ITEM_SELECTED_STATUS: "item_selected_status",
-  PREVIOUS_SELECTED_STATE: "previous_selected_state",
-};
-
 // ---------------- EVENTS ---------------------
 export const AD_EVENT = {
   ad_break_start: "player_ad_break_start",

package/appUtils/accessibilityManager/index.ts

@@ -1,9 +1,9 @@
 import { BehaviorSubject } from "rxjs";
 import { accessibilityManagerLogger as logger } from "./logger";
-import { TTSManager } from "../platform";
+import { TTSManager } from "../platform/platformUtils";
 import { BUTTON_ACCESSIBILITY_KEYS } from "./const";
 import { AccessibilityRole } from "react-native";
-import { toString } from "../../utils";
+import _ from "lodash";
 
 export class AccessibilityManager {
   private static _instance: AccessibilityManager | null = null;
@@ -137,7 +137,7 @@ export class AccessibilityManager {
   }
 
   public getButtonAccessibilityProps(name: string): AccessibilityProps {
-    const buttonName = toString(name);
+    const buttonName = _.toString(name);
 
     const buttonConfig = BUTTON_ACCESSIBILITY_KEYS[buttonName];
 

package/arrayUtils/__tests__/isFilledArray.test.ts

@@ -32,7 +32,7 @@ describe("isFilledArray", () => {
   });
 
   it("NaN is not array", () => {
-    const value = NaN;
+    const value = "";
 
     expect(isFilledArray(value)).toBe(false);
   });

package/arrayUtils/index.ts

@@ -99,17 +99,12 @@ export const makeListOf = (value: unknown, size: number): number[] => {
 
 /** Checks if a value is a non-empty array */
 export function isFilledArray(value: unknown): boolean {
-  return Array.isArray(value) && value.length > 0;
-}
-
-/** Checks if a value is a empty array */
-export function isEmptyArray(value: unknown): boolean {
-  return Array.isArray(value) && value.length === 0;
+  return R.is(Array, value) && R.length(value) > 0;
 }
 
 // get random item from the list
 export const sample = (xs: unknown[]): unknown => {
-  invariant(Array.isArray(xs), `input value is not an array: ${xs}`);
+  invariant(R.is(Array, xs), `input value is not a array: ${xs}`);
   invariant(isFilledArray(xs), `input array is empty: ${xs}`);
 
   const index = Math.floor(Math.random() * xs.length);

package/configurationUtils/__tests__/configurationUtils.test.js

@@ -1,8 +1,11 @@
+import * as R from "ramda";
 import {
   populateConfigurationValues,
+  imageSrcFromMediaItem,
   getBoolFromConfigValue,
   remapUpdatedKeys,
 } from "../";
+import { entry } from "./testEntry";
 
 describe("getBoolFromConfigValue", () => {
   it('returns true if value is "true" string', () => {
@@ -54,6 +57,34 @@ describe("getBoolFromConfigValue", () => {
   });
 });
 
+describe("imageSrcFromMediaItem", () => {
+  describe("returns the src value of first media_item", () => {
+    it("when the matching key is found and the src is not empty", () => {
+      const result = imageSrcFromMediaItem(entry, ["logo_thumbnail"]);
+
+      expect(result).toEqual(entry.media_group[1].media_item[0].src);
+      expect(result).not.toEqual("");
+    });
+  });
+
+  it("returns a media item with the 'image_base' key as a fallback", () => {
+    const result = imageSrcFromMediaItem(entry, ["does_not_exist"]);
+    const fallback = entry.media_group[0].media_item[0];
+    expect(result).toEqual(fallback.src);
+    expect(fallback.key).toBe("image_base");
+  });
+
+  it("returns undefined if the key was found but the source was empty", () => {
+    const badEntry = R.set(
+      R.lensPath(["media_group", 0, "media_item", 0, "src"]),
+      "",
+      entry
+    );
+
+    expect(imageSrcFromMediaItem(badEntry, ["image_base"])).toBeUndefined();
+  });
+});
+
 describe("populateConfigurationValues", () => {
   it("transforms and returns the valid values", () => {
     const fields = [

package/configurationUtils/index.ts

@@ -1,12 +1,6 @@
 /// <reference types="@applicaster/applicaster-types" />
 import * as R from "ramda";
 import { Platform } from "react-native";
-import {
-  isFilledArray,
-  isEmptyArray,
-} from "@applicaster/zapp-react-native-utils/arrayUtils";
-import { isEmpty } from "@applicaster/zapp-react-native-utils/utils";
-
 import { applyTransform } from "../transform";
 import { ManifestField } from "../types";
 import { isNilOrEmpty } from "../reactUtils/helpers";
@@ -128,77 +122,54 @@ export function flattenFields(
 }
 
 /**
- * Retrieves all media items from the entry's media_group that are of type "image" or "thumbnail".
- *
- * @param {ZappEntry} entry - The entry object containing the media_group array.
- * @returns {Option<ZappMediaItem[]>} An array of media items of type "image" or "thumbnail", or undefined if no media_group is present.
- */
-export function getMediaItems(entry: ZappEntry): Option<ZappMediaItem[]> {
-  const mediaGroup = entry?.media_group || [];
-
-  if (isEmptyArray(mediaGroup)) {
-    return undefined;
-  }
-
-  const mediaItems = mediaGroup
-    .filter((group) => ["image", "thumbnail"].includes(group.type))
-    .flatMap((group) =>
-      Array.isArray(group.media_item) ? group.media_item : [group.media_item]
-    );
-
-  if (isFilledArray(mediaItems)) {
-    return mediaItems;
-  }
-
-  return undefined;
-}
-
-/**
- * Retrieves the "src" value from a media item in the entry's media group,
- * based on a provided key, with fallback logic.
- *
- * Fallback order:
- *   1. Attempts to find a media item with the specified key (or "image_base" if none provided).
- *   2. If not found, attempts to find a media item with the key "image_base".
- *   3. If still not found, falls back to the first available media item.
- *
- * Special handling: If the resolved item's "src" is an empty string, returns undefined,
- * since empty URIs are invalid in some platforms (e.g., React Native).
- *
- * @param {ZappEntry} entry - The entry object containing a media group.
- * @param {string[] | unknown} arg - A single-element array containing the key to look up, or any unknown value.
- * @returns {?string} The "src" URI from the matched media item, or undefined if not found or empty.
+ * Retrieves the value of the "src" in the first media_item
+ * that has the matching key provided in args.
+ * Fallbacks: "image_base" key, or first media_item that has any "src"
+ * @param {Object} entry    Single entry from a feed
+ * @param {Array} arg      Array with a single element - the key of the media item
+ *                          from which the "src" should be retrieved
+ * @returns {?String}       Value of "src", usually a URI
  */
 export function imageSrcFromMediaItem(
   entry: ZappEntry,
   arg: string[] | unknown
-): Option<string> {
+) {
   const args: unknown = R.unless(Array.isArray, Array)(arg || []);
   const imageKey: string = args?.[0] || "image_base"; // always a single key in this function
+  const mediaGroup = R.path<ZappMediaGroup[]>(["media_group"], entry);
 
-  const mediaItems = getMediaItems(entry);
-
-  if (!mediaItems) {
+  if (!mediaGroup) {
     return undefined;
   }
 
-  // Try to find the item with the given key
-  let foundItem = mediaItems.find((item) => item.key === imageKey);
+  const hasTypeImageOrThumbnail = R.either(
+    R.propEq("type", "image"),
+    R.propEq("type", "thumbnail")
+  );
+
+  const pickMediaItemProp = R.prop<ZappMediaItem>("media_item");
 
-  // If not found and key was not "image_base", try to find "image_base"
-  if (!foundItem && imageKey !== "image_base") {
-    foundItem = mediaItems.find((item) => item.key === "image_base");
-  }
+  const mediaItems = R.compose(
+    R.flatten,
+    R.map(pickMediaItemProp),
+    R.filter(hasTypeImageOrThumbnail)
+  )(mediaGroup);
 
-  // If still not found, default to first item
-  if (!foundItem) {
-    foundItem = mediaItems[0];
+  if (!mediaItems) {
+    return undefined;
   }
 
-  const src = foundItem?.src;
-
-  // React Native quirk: empty string is invalid for URIs
-  return isEmpty(src) ? undefined : src;
+  const src = R.compose(
+    R.prop("src"),
+    R.defaultTo(R.head(mediaItems)),
+    R.when(R.isNil, () => R.find(R.propEq("key", "image_base"), mediaItems)),
+    R.find(R.propEq("key", imageKey))
+  )(mediaItems);
+
+  // Special case for react native - uri cannot be an empty string (yellow warning).
+  // R.isEmpty is tailored specifically for checks like these,
+  // it returns false for undefined values.
+  return R.isEmpty(src) ? undefined : src;
 }
 
 /**

package/focusManager/FocusManager.ts

@@ -243,10 +243,12 @@ class FocusManager {
   }
 
   blurPrevious(options?: FocusManager.Android.CallbackOptions) {
-    FocusManager.instance.prevFocused?.onBlur?.(
-      FocusManager.instance.prevFocused,
-      options ?? {} // Adding fallback to avoid potential regression caused by #7509
-    );
+    if (options) {
+      FocusManager.instance.prevFocused?.onBlur?.(
+        FocusManager.instance.prevFocused,
+        options
+      );
+    }
   }
 
   onDisableFocusChange = (id) => {

package/manifestUtils/{_internals/index.js → _internals.js}

@@ -1,7 +1,6 @@
 const R = require("ramda");
 const camelize = require("camelize");
-
-const { getDefaultConfiguration } = require("./getDefaultConfiguration");
+const { defaultConfigurations } = require("./defaultManifestConfigurations");
 
 const toSnakeCase = R.compose(R.replace(/\s/g, "_"), R.toLower, R.trim);
 
@@ -174,6 +173,30 @@ function generateFieldsFromDefaultsWithoutPrefixedLabel(
   )(fields);
 }
 
+/**
+ * returns default configuration keys for provided plugin type
+ * @param {('general-content'|'player')} pluginType
+ * @param options manifest generator information
+ * @param {string} options.version manifest version
+ * @param {string} options.platform qb platform value
+ */
+function getDefaultConfiguration(pluginType, options) {
+  const defConfig = R.compose(
+    R.unless(R.isNil, (fn) => fn(options)),
+    R.propOr(null, pluginType)
+  )(defaultConfigurations);
+
+  if (!defConfig) {
+    const availableKeys = R.keys(defaultConfigurations);
+
+    const message = `Requested key "${pluginType}" doesn't exist in the default configuration\nAvailable keys: ${availableKeys}`;
+    // eslint-disable-next-line no-console
+    console.warn(message);
+  }
+
+  return defConfig;
+}
+
 module.exports = {
   toSnakeCase,
   toCamelCase,

package/manifestUtils/createConfig.js

@@ -1,8 +1,5 @@
 const R = require("ramda");
-
-const {
-  getDefaultConfiguration,
-} = require("./_internals/getDefaultConfiguration");
+const { getDefaultConfiguration } = require("./_internals");
 
 const indexByKey = R.indexBy((obj) => R.prop(obj.group ? "label" : "key", obj));
 const propIfExist = R.curry((prop) => R.when(R.prop(prop), R.prop(prop)));