@applicaster/zapp-react-native-utils 16.0.0-rc.7 → 16.0.0-rc.71

package/playerUtils/isAudioItem.ts

@@ -0,0 +1,26 @@
+import { isString } from "@applicaster/zapp-react-native-utils/typeGuards";
+
+/**
+ * Lives in its own module rather than in `playerUtils/index.ts` because that
+ * barrel imports `playerManager`, and files inside `appUtils/playerManager/`
+ * need this helper. Importing it from the barrel there would create a require
+ * cycle:
+ *
+ *   playerManager/index -> player -> playerUtils/index -> playerManager/index
+ *
+ * Re-exported from the barrel, so existing importers are unaffected.
+ */
+export const isAudioItem = (item: Option<ZappEntry>) => {
+  if (
+    isString(item?.content?.type) &&
+    item?.content?.type?.includes?.("audio")
+  ) {
+    return true;
+  }
+
+  if (isString(item?.type?.value) && item?.type?.value?.includes?.("audio")) {
+    return true;
+  }
+
+  return false;
+};

package/playerUtils/resolvePlayerTitleSubtitle.ts

@@ -0,0 +1,76 @@
+import {
+  createConfigValueGetter,
+  resolvePlayerContentText,
+  VIDEO_PLAYER_CONTENT_DATA_KEYS,
+  AUDIO_PLAYER_CONTENT_DATA_KEYS,
+} from "./contentDataKeys";
+import type { PlayerContentDataKeys } from "./contentDataKeys";
+
+/**
+ * Resolves the player's Title/Subtitle text as raw values (string | number |
+ * null). Called by `Player.getContent()`, which publishes the result on the
+ * player's content channel; every consumer - the mobile/TV transport
+ * controls, `ProgramInfo`, the TV audio player, the Chromecast controller and
+ * the native bridge - reads it from there rather than resolving for itself.
+ *
+ * `dataKeys` selects which Studio-configured key set backs the resolution:
+ * omit it for the default (mobile) `PLAYER_CONTENT_DATA_KEYS` set, or pass
+ * an explicit set (e.g. `VIDEO_PLAYER_CONTENT_DATA_KEYS`) for platforms/content
+ * types that keep separate Studio configuration for this text. Getting the
+ * key set backwards would make one platform read another platform's
+ * configuration, so every caller must be explicit about which set it wants.
+ *
+ * Keeping this in one place is what stops the dot-path / key-set resolution
+ * logic (`resolvePlayerContentText`) from being duplicated per caller.
+ */
+export const resolvePlayerTitleSubtitle = ({
+  entry,
+  pluginConfiguration,
+  dataKeys,
+}: {
+  entry: Option<ZappEntry>;
+  pluginConfiguration: Option<Record<string, any>>;
+  dataKeys?: PlayerContentDataKeys;
+}): {
+  title: Option<string | number>;
+  summary: Option<string | number>;
+} => {
+  const value = createConfigValueGetter(pluginConfiguration);
+
+  const title =
+    resolvePlayerContentText({ entry, field: "title", value, dataKeys }) ??
+    null;
+
+  const summary =
+    resolvePlayerContentText({
+      entry,
+      field: "subtitle",
+      value,
+      dataKeys,
+    }) ?? null;
+
+  return { title, summary };
+};
+
+/**
+ * Picks which Studio-configured key set backs a Title/Subtitle resolution,
+ * from the full three-way choice: TV audio, TV video, or mobile. Each of
+ * those ships separate Studio configuration for this text; getting this
+ * backwards would make one platform (or content type) read another's
+ * configuration.
+ */
+export const getPlayerContentDataKeys = ({
+  isTV,
+  isAudioContent,
+}: {
+  isTV: boolean;
+  isAudioContent: boolean;
+}): PlayerContentDataKeys | undefined => {
+  if (!isTV) {
+    return undefined;
+  }
+
+  return isAudioContent
+    ? AUDIO_PLAYER_CONTENT_DATA_KEYS
+    : VIDEO_PLAYER_CONTENT_DATA_KEYS;
+};

package/reactHooks/actions/index.ts

@@ -1,8 +1,12 @@
 /// <reference types="@applicaster/applicaster-types" />
 /* eslint-disable @typescript-eslint/no-unused-vars */
-import { Context, useContext, useState } from "react";
+import { Context, useCallback, useContext, useEffect, useState } from "react";
 import { ActionsContext } from "@applicaster/zapp-react-native-ui-components/Contexts/ActionsContext";
 
+import {
+  observeEntryState,
+  RegisteredActionValue,
+} from "../../uiActionsRegistrator";
 import { reactHooksLogger } from "../logger";
 
 const logger = reactHooksLogger.addSubsystem("actions");
@@ -46,3 +50,49 @@ export function useActions<T = unknown>(plugId: string): any {
 
   return context;
 }
+
+export type UseEntryActionState = {
+  state: CellActionEntryState | undefined;
+  invokeAction: (options?: InvokeArgsOptions) => void;
+};
+
+/**
+ * Subscribes a component to a single action's state for a given `entry`.
+ *
+ * It observes state changes reactively via `observeEntryState` (which is backed
+ * by the action's `addListener`), seeds the initial value synchronously from
+ * `initialEntryState`, and returns a memoized `invokeAction` that forwards
+ * optimistic `updateState` updates back into local state.
+ *
+ * This is the single, unified way to drive an action button - it works the same
+ * for registry actions, legacy context-provider actions and entry actions.
+ */
+export function useEntryActionState(
+  action: RegisteredActionValue | undefined,
+  entry: ZappEntry | ZappFeed
+): UseEntryActionState {
+  const [state, setState] = useState<CellActionEntryState | undefined>(() =>
+    action?.initialEntryState?.(entry)
+  );
+
+  const entryId = (entry as ZappEntry)?.id;
+
+  useEffect(() => {
+    if (!action) return undefined;
+
+    const subscription = observeEntryState(action, entry).subscribe(setState);
+
+    return () => subscription.unsubscribe();
+    // eslint-disable-next-line @wogns3623/better-exhaustive-deps/exhaustive-deps
+  }, [action, entryId]);
+
+  const invokeAction = useCallback(
+    (options: InvokeArgsOptions = {}) => {
+      action?.invokeAction?.(entry, { updateState: setState, ...options });
+    },
+    // eslint-disable-next-line @wogns3623/better-exhaustive-deps/exhaustive-deps
+    [action, entryId]
+  );
+
+  return { state, invokeAction };
+}

package/reactHooks/cell-click/index.ts

@@ -4,6 +4,7 @@ import * as React from "react";
 import * as R from "ramda";
 import { handleActionSchemeUrl } from "@applicaster/quick-brick-core/App/DeepLinking/URLSchemeHandler/SchemeHandlerHooks/useUrlSchemeHandler";
 import { CellTapContext } from "@applicaster/zapp-react-native-ui-components/Contexts/CellTapContext";
+import { useUIComponentContext } from "@applicaster/zapp-react-native-ui-components/Contexts/UIComponentContext";
 import {
   useNavigation,
   useProfilerLogging,
@@ -28,7 +29,6 @@ import { useScreenStateStore } from "../navigation/useScreenStateStore";
 type Props = {
   item?: ZappEntry;
   index?: number;
-  component?: ZappUIComponent;
   zappPipesData?: ZappPipesData;
 };
 
@@ -37,24 +37,25 @@ type onPressReturnFn =
   | (() => void);
 
 export const useCellClick = ({
-  component,
   zappPipesData,
   item,
-}: Props): onPressReturnFn => {
+}: Props = {}): onPressReturnFn => {
   const { push, currentRoute } = useNavigation();
   const { pathname } = useRoute();
   const screenStateStore = useScreenStateStore();
 
   const onCellTap: Option<Function> = React.useContext(CellTapContext);
   const actionExecutor = React.useContext(ActionExecutorContext);
+  const component = useUIComponentContext();
   const screenData = useCurrentScreenData();
   const screenState = useScreenContext()?.options;
+  const entry = useScreenContext()?.entry;
 
   const cellSelectable = toBooleanWithDefaultTrue(
     component?.rules?.component_cells_selectable
   );
 
-  const [entryContext, setEntryContext] =
+  const [_entryContext, setEntryContext] =
     ZappPipesEntryContext.useZappPipesContext(pathname);
 
   const logTimestamp = useProfilerLogging();
@@ -89,7 +90,8 @@ export const useCellClick = ({
           screenState,
           screenRoute: pathname,
           screenStateStore,
-          entryContext,
+          entryContext: selectedItem,
+          screenEntry: entry,
         });
       }
 
@@ -117,14 +119,20 @@ export const useCellClick = ({
       }
     },
     [
-      onCellTap,
-      currentRoute,
+      item,
       setEntryContext,
-      pathname,
-      push,
       sendAnalyticsOnPress,
+      logTimestamp,
+      pathname,
+      component,
+      onCellTap,
+      entry,
+      actionExecutor,
       screenData,
       screenState,
+      screenStateStore,
+      currentRoute,
+      push,
     ]
   );
 
@@ -138,5 +146,5 @@ export const useCellClick = ({
     onPressRef.current = onPress;
   }
 
-  return React.useCallback(onPressRef.current, []);
+  return React.useCallback(onPressRef.current, [item]);
 };

package/reactHooks/feed/__mocks__/useMarkPipesDataStale.ts

@@ -0,0 +1,4 @@
+export const useMarkPipesDataStale = jest.fn();
+
+/** @deprecated alias of useMarkPipesDataStale */
+export const usePipesCacheReset = useMarkPipesDataStale;

package/reactHooks/feed/__tests__/useInflatedUrl.test.tsx

@@ -242,4 +242,29 @@ describe("useGetUrlInflater", () => {
     const url = result.current(source, mapping);
     expect(url).toBe("https://foo.com/shows/A123?q=user%20query");
   });
+
+  it("handles search queries with apostrophes without HTML entity escaping or URL truncation", () => {
+    const source =
+      "https://api.pc-cms.tele.quebec/api/applicaster/v1/mobile/search?q={{q}}";
+
+    const mapping = {
+      q: { source: "search", property: "q" },
+    };
+
+    const searchContext = getSearchContext("L'aventure", mapping);
+
+    const result = getInflatedDataSourceUrl({
+      source,
+      contexts: {
+        search: searchContext,
+      },
+      mapping,
+    });
+
+    expect(result).toBe(
+      "https://api.pc-cms.tele.quebec/api/applicaster/v1/mobile/search?q=L'aventure"
+    );
+
+    expect(result).not.toContain("'");
+  });
 });

package/reactHooks/feed/index.ts

@@ -6,7 +6,11 @@ export { useEntryScreenId } from "./useEntryScreenId";
 
 export { useBuildPipesUrl } from "./useBuildPipesUrl";
 
-export { usePipesCacheReset } from "./usePipesCacheReset";
+export {
+  useMarkPipesDataStale,
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
+  usePipesCacheReset,
+} from "./useMarkPipesDataStale";
 
 export { useBatchLoading } from "./useBatchLoading";
 

package/reactHooks/feed/useBatchLoading.ts

@@ -159,9 +159,17 @@ export const useBatchLoading = (
     options.riverId,
   ]);
 
+  // Initial preload only. Batch loading warms the first batch of component
+  // feeds and signals readiness; the feed set is frozen at mount on purpose.
+  // Per-component loads and reloads (including stale revalidation) are owned by
+  // useFeedLoader in ZappPipesDataConnector. Re-running on `feeds`/input changes
+  // would re-fire on every store update and cause redundant dispatch storms, so
+  // this intentionally runs once on mount.
+  /* eslint-disable @wogns3623/better-exhaustive-deps/exhaustive-deps */
   React.useEffect(() => {
     runBatchLoading();
-  }, [runBatchLoading]); // Adding runBatchLoading as a dependency to ensure that it reloads feeds when clearPipesData is called
+  }, []);
+  /* eslint-enable @wogns3623/better-exhaustive-deps/exhaustive-deps */
 
   React.useEffect(() => {
     // check if all feeds are ready and set hasEverBeenReady to true

package/reactHooks/feed/{usePipesCacheReset.ts → useMarkPipesDataStale.ts}

@@ -2,17 +2,19 @@ import React from "react";
 
 import { getDatasourceUrl } from "@applicaster/zapp-react-native-ui-components/Decorators/RiverFeedLoader/utils/getDatasourceUrl";
 import { usePipesContexts } from "@applicaster/zapp-react-native-ui-components/Decorators/RiverFeedLoader/utils/usePipesContexts";
-import { clearPipesData } from "@applicaster/zapp-react-native-redux/ZappPipes";
+import { markPipesDataStale } from "@applicaster/zapp-react-native-redux/ZappPipes";
 
 import { useRoute } from "../navigation";
 import { useAppDispatch } from "@applicaster/zapp-react-native-redux";
 
 /**
- * reset river components cache when screen is unmounted
+ * Mark a river's `clear_cache_on_reload` feeds as stale when the screen is
+ * unmounted. The cached data is kept (so a screen sharing the same feed does
+ * not lose it mid-mount) and revalidated on next access.
  * @param {string} riverId screen id
  * @param {Array} riverComponents list of UI components
  */
-export const usePipesCacheReset = (riverId, riverComponents) => {
+export const useMarkPipesDataStale = (riverId, riverComponents) => {
   const dispatch = useAppDispatch();
   const { screenData, pathname } = useRoute();
   const pipesContexts = usePipesContexts(riverId, pathname);
@@ -35,10 +37,16 @@ export const usePipesCacheReset = (riverId, riverComponents) => {
           );
 
           if (url) {
-            dispatch(clearPipesData(url, { riverId }));
+            dispatch(markPipesDataStale(url, { riverId }));
           }
         }
       });
     };
   }, []);
 };
+
+/**
+ * @deprecated Renamed to `useMarkPipesDataStale`. Kept as an alias for backward
+ * compatibility with external consumers.
+ */
+export const usePipesCacheReset = useMarkPipesDataStale;

package/reactHooks/index.ts

@@ -17,3 +17,5 @@ export * from "./screen";
 export * from "./state";
 
 export * from "./events";
+
+export * from "./utils";

package/reactHooks/layout/index.ts

@@ -49,7 +49,7 @@ export function useStatusBarHeight() {
   });
 }
 
-const getNavbarHeight = () => {
+export const getNavbarHeight = () => {
   return isTV() ? 60 : platformSelect({ ios: 44, android: 56 });
 };
 

package/reactHooks/navigation/__mocks__/index.ts

@@ -38,3 +38,7 @@ export const useNavigationPluginData = jest.fn().mockReturnValue(mockMenu);
 export const useIsNavBarVisible = jest.fn().mockReturnValue(true);
 
 export const useIsScreenActive = jest.fn().mockReturnValue(true);
+
+export const isScreenActiveForRoute = jest.fn(
+  (route, currentRoute) => route === currentRoute
+);

package/reactHooks/navigation/__tests__/useIsScreenActive.test.ts

@@ -0,0 +1,42 @@
+import { isScreenActiveForRoute } from "../useIsScreenActive";
+
+describe("isScreenActiveForRoute", () => {
+  const route = "/river/home/river/tabs";
+  const currentRoute = "/river/home/river/tabs";
+
+  it("returns false when route does not match", () => {
+    expect(
+      isScreenActiveForRoute(route, "/river/home", { visible: false })
+    ).toBe(false);
+  });
+
+  it("keeps underlying screen active when video modal is docked", () => {
+    expect(
+      isScreenActiveForRoute(route, currentRoute, {
+        visible: true,
+        mode: "MINIMIZED",
+      })
+    ).toBe(true);
+  });
+
+  it.each(["FULLSCREEN", "MAXIMIZED", "PIP"])(
+    "deactivates underlying screen when video modal is visible",
+    (mode) => {
+      expect(
+        isScreenActiveForRoute(route, currentRoute, {
+          visible: true,
+          mode,
+        })
+      ).toBe(false);
+    }
+  );
+
+  it("keeps video-modal route active when video modal is open", () => {
+    expect(
+      isScreenActiveForRoute("video-modal/123", currentRoute, {
+        visible: true,
+        mode: "FULLSCREEN",
+      })
+    ).toBe(true);
+  });
+});

package/reactHooks/navigation/index.ts

@@ -32,7 +32,7 @@ export { useNavigationType } from "./useNavigationType";
 
 export { useGetBottomTabBarHeight } from "./useGetBottomTabBarHeight";
 
-export { useIsScreenActive } from "./useIsScreenActive";
+export { useIsScreenActive, isScreenActiveForRoute } from "./useIsScreenActive";
 
 export { useProfilerLogging } from "./useProfilerLogging";
 

package/reactHooks/navigation/useIsScreenActive.ts

@@ -2,20 +2,41 @@ import { ROUTE_TYPES } from "@applicaster/zapp-react-native-utils/navigationUtil
 import { useNavigation } from "./useNavigation";
 import { usePathname } from "./usePathname";
 
-// If current screen is active/focused (visible to the user)
-export const useIsScreenActive = () => {
-  const pathname = usePathname();
-  const { currentRoute, videoModalState } = useNavigation();
+type VideoModalState = {
+  visible?: boolean;
+  mode?: string;
+} | null;
 
-  if (videoModalState.visible) {
-    if (pathname.includes(ROUTE_TYPES.VIDEO_MODAL)) {
+/**
+ * Whether a navigation route should be treated as the active/focused screen.
+ * Docked (MINIMIZED) video modal does not deactivate the underlying screen —
+ * only FULLSCREEN / MAXIMIZED / PIP do.
+ */
+export function isScreenActiveForRoute(
+  route: string,
+  currentRoute: string,
+  videoModalState: VideoModalState
+) {
+  if (videoModalState?.visible) {
+    if (route.includes(ROUTE_TYPES.VIDEO_MODAL)) {
       return true;
     }
 
-    if (["FULLSCREEN", "MAXIMIZED", "PIP"].includes(videoModalState.mode)) {
+    if (
+      ["FULLSCREEN", "MAXIMIZED", "PIP"].includes(videoModalState.mode ?? "")
+    ) {
       return false;
     }
+    // MINIMIZED (docked): fall through — underlying screen stays active
   }
 
-  return pathname === currentRoute;
+  return route === currentRoute;
+}
+
+// If current screen is active/focused (visible to the user)
+export const useIsScreenActive = () => {
+  const pathname = usePathname();
+  const { currentRoute, videoModalState } = useNavigation();
+
+  return isScreenActiveForRoute(pathname, currentRoute, videoModalState);
 };

package/reactHooks/state/useComponentScreenState.ts

@@ -41,5 +41,5 @@ export const useComponentScreenState = <T = unknown>(
     [componentId, store]
   );
 
-  return [value, setValue] as const;
+  return [value, setValue];
 };

package/reactHooks/usePluginConfiguration.ts

@@ -24,7 +24,10 @@ export function parsePluginConfiguration(plugin, manifest) {
   return populateFields(plugin, manifest.custom_configuration_fields);
 }
 
-export function usePluginConfiguration<T, S>(identifier, manifest) {
+export function usePluginConfiguration<T = any, S = Record<string, any>>(
+  identifier: string,
+  manifest?: any
+) {
   const plugins = usePlugins();
 
   const plugin = useMemo(

package/reactHooks/utils/__tests__/index.test.js

@@ -1,5 +1,5 @@
-import { usePrevious, useIsInitialRender } from "../";
-import { renderHook, cleanup } from "@testing-library/react-native";
+import { usePrevious, useIsInitialRender, useForceUpdate } from "../";
+import { renderHook, cleanup, act } from "@testing-library/react-native";
 
 describe("usePrevious", () => {
   it("renders", () => {
@@ -49,3 +49,23 @@ describe("useIsInitialRender", () => {
     expect(result.current).toBe(false);
   });
 });
+
+describe("useForceUpdate", () => {
+  it("forces component to re-render when called", () => {
+    let renderCount = 0;
+
+    const { result } = renderHook(() => {
+      renderCount++;
+
+      return useForceUpdate();
+    });
+
+    expect(renderCount).toBe(1);
+
+    act(() => {
+      result.current();
+    });
+
+    expect(renderCount).toBe(2);
+  });
+});

package/reactHooks/utils/index.ts

@@ -1,4 +1,4 @@
-import { useRef, useEffect } from "react";
+import { useEffect, useReducer, useRef } from "react";
 
 /**
  * This hook returns a previous value that was passed to it.
@@ -31,6 +31,16 @@ export const useIsInitialRender = (): boolean => {
   return isInitialRenderRef.current;
 };
 
+/**
+ * Returns a function that forces a re-render of the component when invoked.
+ * @return {() => void}
+ */
+export const useForceUpdate = (): (() => void) => {
+  const [, forceUpdate] = useReducer((n: number) => n + 1, 0);
+
+  return forceUpdate;
+};
+
 export const checkIsLocalFeed = (feedUrl) => feedUrl?.startsWith("pipesv2://");
 
 export const shouldDispatchData = (
@@ -40,6 +50,7 @@ export const shouldDispatchData = (
 ) => {
   const currentFeedHasData = feed?.data;
   const isLocalFeed = checkIsLocalFeed(url);
+  const isFeedStale = feed?.stale;
 
-  return !currentFeedHasData || clearCache || isLocalFeed;
+  return !currentFeedHasData || clearCache || isFeedStale || isLocalFeed;
 };

package/reactHooks/videoModal/hooks/useVideoModalScreenData.tsx

@@ -2,6 +2,12 @@ import React from "react";
 import { useContentTypes } from "@applicaster/zapp-react-native-redux/hooks";
 import { useNavigation } from "@applicaster/zapp-react-native-utils/reactHooks";
 import { useRivers } from "../../state";
+import { createLogger } from "../../../logger";
+
+const { log_warning } = createLogger({
+  subsystem: "zapp-react-native-utils/reactHooks/videoModal",
+  category: "useVideoModalScreenData",
+});
 
 export const useVideoModalScreenData = ():
   | (ZappEntry & { targetScreen: any }) // TODO: fix ZappEntry type ( was ZappRiver but conflict )
@@ -14,10 +20,22 @@ export const useVideoModalScreenData = ():
   const rivers = useRivers();
 
   return React.useMemo(() => {
-    if (item?.type?.value) {
-      const screenId = contentTypes[item?.type?.value].screen_id;
+    const itemType = item?.type?.value;
+
+    if (!itemType) {
+      return;
+    }
 
-      return { ...item, targetScreen: rivers?.[screenId] };
+    const screenId = contentTypes[itemType]?.screen_id;
+
+    if (!screenId) {
+      log_warning(
+        `Type mapping is missing for item type: ${itemType}, title: ${item.title}`
+      );
+
+      return;
     }
-  }, [item]);
+
+    return { ...item, targetScreen: rivers?.[screenId] };
+  }, [contentTypes, item, rivers]);
 };

package/riverComponetsMeasurementProvider/index.tsx

@@ -1,10 +1,20 @@
 import * as React from "react";
-import { NativeModules, StyleSheet, View } from "react-native";
+import { NativeModules, View, StyleSheet } from "react-native";
 import { getXray } from "@applicaster/zapp-react-native-utils/logger";
 
-import { isApplePlatform, isWeb } from "../reactUtils";
+import { isApplePlatform, isWeb, isTV } from "../reactUtils";
 import { useRivers } from "../reactHooks";
 
+const isTVPlatform = isTV();
+
+const styles = StyleSheet.create({
+  container: isTVPlatform
+    ? {
+        flex: 1,
+      }
+    : {},
+});
+
 const layoutReducer = (state, { payload }) => {
   return state.map((item, index, _state) => ({
     height: index === payload.index ? payload.height : item.height,
@@ -30,12 +40,6 @@ type MeasurementContext = {
   onLayout: (index: number) => (event) => void;
 };
 
-const styles = StyleSheet.create({
-  container: {
-    flex: 1,
-  },
-});
-
 const { Logger } = getXray();
 
 const logger = new Logger("general", "ui");