@applicaster/zapp-react-native-utils 14.0.0-alpha.4748018412 → 14.0.0-alpha.5333112458

package/analyticsUtils/AnalyticsEvents/helper.ts

@@ -4,9 +4,12 @@ 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-utils/storage/StorageMultiSelectProvider";
 
 export enum OfflineItemState {
   notExist = "NOT_EXISTS",
@@ -102,6 +105,84 @@ 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 } from "../events";
-
+import { ANALYTICS_CORE_EVENTS, ACTION_TYPE } from "../events";
 import { postAnalyticEvent } from "../manager";
 import {
   replaceAnalyticsPropsNils,
   eventForEntry,
   eventForComponent,
   extensionsEvents,
+  getLocalStorageSetPayload,
+  getLocalStorageToggleFlagPayload,
 } from "./helper";
 
 declare type AnalyticsDefaultHelperProperties = {
@@ -26,7 +26,16 @@ export const sendOnClickEvent = ({
   const castedExtraProps: ExtraProps = extraProps;
   const componentData = component || extraProps.component;
   const data = zappPipesData || extraProps.zappPipesData;
-  const eventName = ANALYTICS_CORE_EVENTS.TAP_CELL;
+
+  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;
 
   if (!analyticsScreenData) {
     log_error(
@@ -44,6 +53,7 @@ export const sendOnClickEvent = ({
     ...replaceAnalyticsPropsNils({
       ...analyticsScreenData,
     }),
+    ...actionCellPayload,
   };
 
   if (analyticsCustomProperties) {

package/analyticsUtils/__tests__/analyticsUtils.test.js

@@ -3,8 +3,22 @@ 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,8 +17,11 @@ 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",
 };
@@ -99,6 +102,11 @@ 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,8 +1,9 @@
 import { BehaviorSubject } from "rxjs";
 import { accessibilityManagerLogger as logger } from "./logger";
-import { TTSManager } from "../platform/platformUtils";
+import { TTSManager } from "../platform";
 import { BUTTON_ACCESSIBILITY_KEYS } from "./const";
 import { AccessibilityRole } from "react-native";
+import { toString } from "../../utils";
 
 export class AccessibilityManager {
   private static _instance: AccessibilityManager | null = null;
@@ -135,17 +136,22 @@ export class AccessibilityManager {
     });
   }
 
-  public getButtonAccessibilityProps(buttonName: string): AccessibilityProps {
+  public getButtonAccessibilityProps(name: string): AccessibilityProps {
+    const buttonName = toString(name);
+
     const buttonConfig = BUTTON_ACCESSIBILITY_KEYS[buttonName];
 
     if (!buttonConfig) {
       return {
+        accessible: true,
         accessibilityLabel: buttonName,
         accessibilityHint: `Press button to perform action on ${buttonName}`,
         "aria-label": buttonName,
         "aria-description": `Press button to perform action on ${buttonName}`,
         accessibilityRole: "button" as AccessibilityRole,
         "aria-role": "button",
+        role: "button",
+        tabindex: 0,
       };
     }
 
@@ -159,23 +165,29 @@ export class AccessibilityManager {
       `Press button to perform action on ${buttonName}`;
 
     return {
+      accessible: true,
       accessibilityLabel: label,
       accessibilityHint: hint,
       "aria-label": label,
       "aria-description": hint,
       accessibilityRole: "button" as AccessibilityRole,
       "aria-role": "button",
+      role: "button",
+      tabindex: 0,
     };
   }
 
   public getInputAccessibilityProps(inputName: string): AccessibilityProps {
     return {
+      accessible: true,
       accessibilityLabel: inputName,
       accessibilityHint: `Enter text into ${inputName}`,
       "aria-label": inputName,
       "aria-description": `Enter text into ${inputName}`,
       accessibilityRole: "textbox" as AccessibilityRole,
       "aria-role": "textbox",
+      role: "textbox",
+      tabindex: 0,
     };
   }
 

package/appUtils/contextKeysManager/contextResolver.ts

@@ -1,10 +1,11 @@
 import { ContextKeysManager } from "./index";
 import * as R from "ramda";
 
-interface IResolver {
+export interface IResolver {
   resolve: (string) => Promise<string | number | object>;
 }
 
+// TODO: Rename to ObjectKeyResolver or similar
 export class EntryResolver implements IResolver {
   entry: ZappEntry;
 
@@ -21,6 +22,18 @@ export class EntryResolver implements IResolver {
   }
 }
 
+// TODO: Move to proper place
+
+export class ScreenStateResolver implements IResolver {
+  constructor(private screenStateStore: ScreenStateStore) {}
+
+  async resolve(key: string) {
+    const screenState = this.screenStateStore.getState().data;
+
+    return screenState?.[key];
+  }
+}
+
 export class ContextResolver implements IResolver {
   resolve = async (compositeKey: string) =>
     ContextKeysManager.instance.getKey(compositeKey);

package/appUtils/playerManager/OverlayObserver/OverlaysObserver.ts

@@ -18,13 +18,6 @@ export const { log_verbose, log_debug, log_info, log_error } = createLogger({
   parent: utilsLogger,
 });
 
-type ActionChapter = {
-  type: string;
-  options?: {
-    title: string;
-  };
-};
-
 type ChapterMarkerOriginal = {
   id: string;
   title: string;
@@ -33,14 +26,6 @@ type ChapterMarkerOriginal = {
   actions: ActionChapter[];
 };
 
-export type ChapterMarkerEvent = {
-  id: string;
-  title: string;
-  start_time: number;
-  end_time: number;
-  actions: ActionChapter[];
-};
-
 export type TitleSummaryEvent = {
   title: string | number;
   summary: string | number;

package/appUtils/playerManager/useChapterMarker.tsx

@@ -1,4 +1,3 @@
-import { ChapterMarkerEvent } from "./OverlayObserver/OverlaysObserver";
 import { usePlayer } from "./usePlayer";
 import * as React from "react";
 

package/appUtils/playerManager/usePlayerControllerSetup.tsx

@@ -5,6 +5,9 @@ import { playerManager } from "./index";
 import { useValidatePlayerConfig } from "../../playerUtils/useValidatePlayerConfig";
 import { PlayerRole } from "./conts";
 import { isAppleTV } from "@applicaster/zapp-react-native-ui-components/Helpers/Platform";
+import { TVSeekController } from "../../reactHooks/player/TVSeekControlller/TVSeekController";
+import { KeyInputHandler } from "../keyInputHandler/KeyInputHandler";
+import { isTV } from "../../reactUtils";
 
 // TODO: Rename to ControllerType
 export const usePlayerControllerSetup = ({
@@ -76,5 +79,18 @@ export const usePlayerControllerSetup = ({
     };
   }, [playerId, playerController]);
 
+  useEffect(() => {
+    if (!isTV()) {
+      return;
+    }
+
+    if (playerController) {
+      const seekController = new TVSeekController(playerController);
+      playerController.seekController = seekController;
+
+      return KeyInputHandler.getInstance().addListener(seekController);
+    }
+  }, [playerController]);
+
   return playerController;
 };

package/arrayUtils/__tests__/isEmptyArray.test.ts

@@ -0,0 +1,63 @@
+import { isEmptyArray } from "..";
+
+describe("isEmptyArray", () => {
+  it("non-empty array is not empty", () => {
+    const value = [1, 2, 3];
+
+    expect(isEmptyArray(value)).toBe(false);
+  });
+
+  it("empty array is empty", () => {
+    const value = [];
+
+    expect(isEmptyArray(value)).toBe(true);
+  });
+
+  it("number is not array", () => {
+    const value = 123;
+
+    expect(isEmptyArray(value)).toBe(false);
+  });
+
+  it("string is not array", () => {
+    const value = "vfnjdk";
+
+    expect(isEmptyArray(value)).toBe(false);
+  });
+
+  it("empty string is not array", () => {
+    const value = "";
+
+    expect(isEmptyArray(value)).toBe(false);
+  });
+
+  it("NaN is not array", () => {
+    const value = NaN;
+
+    expect(isEmptyArray(value)).toBe(false);
+  });
+
+  it("object is not array", () => {
+    const value = { test: 1 };
+
+    expect(isEmptyArray(value)).toBe(false);
+  });
+
+  it("empty object is not array", () => {
+    const value = {};
+
+    expect(isEmptyArray(value)).toBe(false);
+  });
+
+  it("undefined is not array", () => {
+    const value = undefined;
+
+    expect(isEmptyArray(value)).toBe(false);
+  });
+
+  it("null is not array", () => {
+    const value = null;
+
+    expect(isEmptyArray(value)).toBe(false);
+  });
+});

package/arrayUtils/__tests__/isFilledArray.test.ts

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

package/arrayUtils/index.ts

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

package/audioPlayerUtils/__tests__/getArtworkImage.test.ts

@@ -0,0 +1,144 @@
+import { getArtworkImage } from "..";
+import { DEFAULT_IMAGE } from "../assets";
+
+describe("getArtworkImage", () => {
+  const entryWithImage = {
+    media_group: [
+      {
+        type: "image",
+        media_item: [
+          { key: "artwork_key", src: "image_from_entry" },
+          { key: "other_key", src: "other_image" },
+        ],
+      },
+    ],
+    extensions: {
+      artwork_key: "artwork_key",
+    },
+  };
+
+  const entryWithoutImage = {
+    media_group: [
+      {
+        type: "image",
+        media_item: [{ key: "other_key", src: "other_image" }],
+      },
+    ],
+    extensions: {
+      artwork_key: "artwork_key",
+    },
+  };
+
+  const pluginConfigWithImage = {
+    artwork_key: "plugin_artwork_key",
+  };
+
+  it("returns image from entry extensions key", () => {
+    const result = getArtworkImage({
+      key: "artwork_key",
+      entry: entryWithImage,
+      plugin_configuration: {},
+    });
+
+    expect(result).toBe("image_from_entry");
+  });
+
+  it("returns image from plugin configuration key if not in entry", () => {
+    const entryNoMatch = {
+      ...entryWithoutImage,
+      extensions: { artwork_key: "not_found_key" },
+    };
+
+    const pluginConfig = {
+      artwork_key: "plugin_artwork_key",
+    };
+
+    const entryWithPluginImage = {
+      ...entryNoMatch,
+      media_group: [
+        {
+          type: "image",
+          media_item: [{ key: "plugin_artwork_key", src: "image_from_plugin" }],
+        },
+      ],
+    };
+
+    const result = getArtworkImage({
+      key: "artwork_key",
+      entry: entryWithPluginImage,
+      plugin_configuration: pluginConfig,
+    });
+
+    expect(result).toBe("image_from_plugin");
+  });
+
+  it("returns DEFAULT_IMAGE if neither entry nor plugin configuration has image", () => {
+    const entryNoImage = {
+      media_group: [
+        {
+          type: "image",
+          media_item: [{ key: "other_key", src: "other_image" }],
+        },
+      ],
+      extensions: { artwork_key: "not_found_key" },
+    };
+
+    const pluginConfig = { artwork_key: "not_found_key" };
+
+    const result = getArtworkImage({
+      key: "artwork_key",
+      entry: entryNoImage,
+      plugin_configuration: pluginConfig,
+    });
+
+    expect(result).toBe(DEFAULT_IMAGE);
+  });
+
+  it("handles undefined key gracefully", () => {
+    const result = getArtworkImage({
+      key: undefined,
+      entry: entryWithImage,
+      plugin_configuration: pluginConfigWithImage,
+    });
+
+    expect(result).toBe(DEFAULT_IMAGE);
+  });
+
+  it("handles missing entry or plugin_configuration gracefully", () => {
+    const result = getArtworkImage({
+      key: "artwork_key",
+      entry: undefined,
+      plugin_configuration: undefined,
+    });
+
+    expect(result).toBe(DEFAULT_IMAGE);
+  });
+
+  it("handles empty media_group", () => {
+    const entryEmptyMedia = {
+      media_group: [],
+      extensions: { artwork_key: "artwork_key" },
+    };
+
+    const result = getArtworkImage({
+      key: "artwork_key",
+      entry: entryEmptyMedia,
+      plugin_configuration: pluginConfigWithImage,
+    });
+
+    expect(result).toBe(DEFAULT_IMAGE);
+  });
+
+  it("handles missing extensions/config keys", () => {
+    const entryNoExt = { media_group: [], extensions: {} };
+    const pluginConfig = {};
+
+    const result = getArtworkImage({
+      key: "artwork_key",
+      entry: entryNoExt,
+      plugin_configuration: pluginConfig,
+    });
+
+    expect(result).toBe(DEFAULT_IMAGE);
+  });
+});

package/audioPlayerUtils/__tests__/getBackgroundImage.test.ts

@@ -0,0 +1,72 @@
+import { getBackgroundImage } from "..";
+import { DEFAULT_IMAGE } from "../assets";
+
+describe("getBackgroundImage", () => {
+  const entryBase = {
+    media_group: [
+      {
+        media_item: [
+          { key: "image_key_1", src: "image_src_1" },
+          { key: "image_key_2", src: "image_src_2" },
+        ],
+        type: "image",
+      },
+    ],
+    extensions: {},
+  };
+
+  const pluginConfigBase = {};
+
+  it("returns image from entry.extensions.image_key if present", () => {
+    const entry = {
+      ...entryBase,
+      extensions: { image_key: "image_key_2" },
+    };
+
+    const result = getBackgroundImage({
+      entry,
+      plugin_configuration: pluginConfigBase,
+    });
+
+    expect(result).toBe("image_src_2");
+  });
+
+  it("returns audio_player_background_image from entry.extensions if present and no image_key image", () => {
+    const entry = {
+      ...entryBase,
+      extensions: { audio_player_background_image: "audio_img_ext" },
+    };
+
+    const result = getBackgroundImage({
+      entry,
+      plugin_configuration: pluginConfigBase,
+    });
+
+    expect(result).toBe("audio_img_ext");
+  });
+
+  it("returns image from plugin_configuration.audio_player_image_key if present and not found in entry.extensions", () => {
+    const entry = { ...entryBase };
+    const plugin_configuration = { audio_player_image_key: "image_key_1" };
+    const result = getBackgroundImage({ entry, plugin_configuration });
+    expect(result).toBe("image_src_1");
+  });
+
+  it("returns audio_player_background_image from plugin_configuration if present and not found in entry/extensions", () => {
+    const entry = { ...entryBase };
+
+    const plugin_configuration = {
+      audio_player_background_image: "audio_img_conf",
+    };
+
+    const result = getBackgroundImage({ entry, plugin_configuration });
+    expect(result).toBe("audio_img_conf");
+  });
+
+  it("returns DEFAULT_IMAGE if nothing is found", () => {
+    const entry = { media_group: [], extensions: {} };
+    const plugin_configuration = {};
+    const result = getBackgroundImage({ entry, plugin_configuration });
+    expect(result).toBe(DEFAULT_IMAGE);
+  });
+});