@applicaster/zapp-react-native-utils 16.0.0-alpha.4880104344 → 16.0.0-alpha.4909430115

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

@@ -11,7 +11,11 @@ import { HooksManager } from "@applicaster/zapp-react-native-utils/appUtils/Hook
 import { LONG_KEY_PRESS_TIMEOUT } from "@applicaster/quick-brick-core/const";
 import { useZappHookModalStore } from "@applicaster/zapp-react-native-ui-components/Contexts/ZappHookModalContext";
 import { HOOKS_EVENTS } from "../../appUtils/HooksManager/constants";
-import { getRiverFromRoute, getTargetRoute } from "../../navigationUtils";
+import {
+  getPathAttributes,
+  getRiverFromRoute,
+  getTargetRoute,
+} from "../../navigationUtils";
 import { useConnectionInfo } from "../connection";
 
 import { isTV, isWeb } from "@applicaster/zapp-react-native-utils/reactUtils";
@@ -32,7 +36,7 @@ export { useNavigationType } from "./useNavigationType";
 
 export { useGetBottomTabBarHeight } from "./useGetBottomTabBarHeight";
 
-export { useIsScreenActive } from "./useIsScreenActive";
+export { useIsScreenActive, isScreenActiveForRoute } from "./useIsScreenActive";
 
 export { useProfilerLogging } from "./useProfilerLogging";
 
@@ -42,6 +46,12 @@ export {
   useContentId,
 } from "./useUniqueRouteSuffix";
 
+function isHookRoute(route: string) {
+  const pathAttributes = getPathAttributes({ pathname: route });
+
+  return pathAttributes[pathAttributes.length - 1]?.screenType === "hooks";
+}
+
 /**
  * This function helps to decide wether the navbar should be presented on the screen
  * based on route and / or screen Data
@@ -50,6 +60,7 @@ export {
  * - players => false
  * - search screen plugin => false
  * - hooks with `showNavBar: true` or `presentFullScreen` not set to true, defaults to no navbar for hook screens
+ *   (only for the hook screen itself - screens pushed on top of a hook are resolved by their own settings)
  * - screens with `allow_screen_plugin_presentation` in general property => false
  *
  * @param {String} route current route of the screen
@@ -85,8 +96,10 @@ export function isNavBarVisible(
     return false;
   }
 
-  /* Match if screen is Hook */
-  if (route.startsWith("/hooks/")) {
+  /* Match if the current screen is the Hook itself. A `startsWith` check would
+   * also match screens pushed on top of a hook (/hooks/<hookId>/river/<riverId>),
+   * whose visibility must be resolved by their own settings instead. */
+  if (isHookRoute(route)) {
     const module = screenData?.module;
 
     if (module === undefined) {

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 { useEffect, useRef } 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 = (

package/stringUtils/__tests__/stringUtils.test.js

@@ -122,6 +122,48 @@ describe("inflate string", () => {
       "this is a string with custom separators"
     );
   });
+
+  it("does not HTML-escape search variables containing single quotes or apostrophes", () => {
+    const string = "https://api.example.com/search?q={{search.query}}";
+    const data = { search: { query: "L'aventure" } };
+
+    expect(inflateString({ string, data })).toBe(
+      "https://api.example.com/search?q=L'aventure"
+    );
+  });
+
+  it("search context with straight apostrophe", () => {
+    const string =
+      "https://api.pc-cms.tele.quebec/api/applicaster/v1/tv/search?q={{search.q}}";
+
+    const data = { search: { q: "l'a" } };
+
+    expect(inflateString({ string, data })).toBe(
+      "https://api.pc-cms.tele.quebec/api/applicaster/v1/tv/search?q=l'a"
+    );
+  });
+
+  it("search context with backtick apostrophe", () => {
+    const string =
+      "https://api.pc-cms.tele.quebec/api/applicaster/v1/tv/search?q={{search.q}}";
+
+    const data = { search: { q: "l`a" } };
+
+    expect(inflateString({ string, data })).toBe(
+      "https://api.pc-cms.tele.quebec/api/applicaster/v1/tv/search?q=l`a"
+    );
+  });
+
+  it("search context with right single quotation mark", () => {
+    const string =
+      "https://api.pc-cms.tele.quebec/api/applicaster/v1/tv/search?q={{search.q}}";
+
+    const data = { search: { q: "l’a" } };
+
+    expect(inflateString({ string, data })).toBe(
+      "https://api.pc-cms.tele.quebec/api/applicaster/v1/tv/search?q=l’a"
+    );
+  });
 });
 
 describe("objectToReadableString", () => {

package/stringUtils/index.ts

@@ -72,8 +72,8 @@ const valueIsNull = (value) => () => value === null;
 const encodeHelper = "encodeURL";
 
 const encodeHandlebarsExpressions = R.compose(
-  R.replace(/{{([^}]+)}}/g, (match, p1) =>
-    p1.includes("search") ? match : `{{{${encodeHelper} ${p1}}}}`
+  R.replace(/{{([^}]+)}}/g, (_, p1) =>
+    p1.includes("search") ? `{{{${p1}}}}` : `{{{${encodeHelper} ${p1}}}}`
   )
 );
 

package/uiActionsRegistrator/__tests__/resolveActionIdentifiers.test.ts

@@ -0,0 +1,93 @@
+import {
+  parseActionIdentifiers,
+  resolveActionIdentifiers,
+} from "../resolveActionIdentifiers";
+import { uiActionsRegistry } from "../registry";
+
+const action = (identifier: string) =>
+  ({ identifier, action: { invokeAction: jest.fn() } }) as any;
+
+describe("parseActionIdentifiers", () => {
+  it("parses comma-separated identifiers", () => {
+    expect(parseActionIdentifiers(" a, b , ,c ")).toEqual(["a", "b", "c"]);
+  });
+
+  it("parses identifier arrays", () => {
+    expect(parseActionIdentifiers([" a ", "", "b", "  ", "c"])).toEqual([
+      "a",
+      "b",
+      "c",
+    ]);
+  });
+
+  it("returns empty array for nil config", () => {
+    expect(parseActionIdentifiers(null)).toEqual([]);
+    expect(parseActionIdentifiers(undefined)).toEqual([]);
+  });
+});
+
+describe("resolveActionIdentifiers", () => {
+  const entry = { id: "entry-1" } as any;
+
+  beforeEach(() => {
+    jest
+      .spyOn(uiActionsRegistry, "getActions")
+      .mockImplementation((identifier) => [action(identifier)] as any);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it("resolves through registry by default", () => {
+    const result = resolveActionIdentifiers({
+      identifiers: "favorites,share",
+      entry,
+    });
+
+    expect(result.map((item) => item.identifier)).toEqual([
+      "favorites",
+      "share",
+    ]);
+
+    expect(uiActionsRegistry.getActions).toHaveBeenCalledWith(
+      "favorites",
+      entry
+    );
+
+    expect(uiActionsRegistry.getActions).toHaveBeenCalledWith("share", entry);
+  });
+
+  it("expands entry_actions through the caller, not the registry", () => {
+    const expanded = [action("entry_action_0"), action("entry_action_1")];
+    const expandEntryActions = jest.fn(() => expanded);
+
+    const unregister = uiActionsRegistry.registerAction("share", {
+      invokeAction: jest.fn(),
+    });
+
+    try {
+      const result = resolveActionIdentifiers({
+        identifiers: "entry_actions,share",
+        entry,
+        expandEntryActions,
+      });
+
+      expect(expandEntryActions).toHaveBeenCalledWith(entry);
+
+      expect(result.map((item) => item.identifier)).toEqual([
+        "entry_action_0",
+        "entry_action_1",
+        "share",
+      ]);
+    } finally {
+      unregister();
+    }
+  });
+
+  it("resolves nothing for entry_actions when the caller cannot expand it", () => {
+    expect(
+      resolveActionIdentifiers({ identifiers: "entry_actions", entry })
+    ).toEqual([]);
+  });
+});

package/uiActionsRegistrator/__tests__/subscribe.test.ts

@@ -0,0 +1,107 @@
+import { isActionAvailableFor, uiActionsRegistry } from "../registry";
+
+const value = { invokeAction: jest.fn() };
+
+describe("uiActionsRegistry.subscribe", () => {
+  it("fires on registration and on unregistration", () => {
+    const listener = jest.fn();
+    const unsubscribe = uiActionsRegistry.subscribe(listener);
+
+    const unregister = uiActionsRegistry.registerAction("late-action", value);
+
+    expect(listener).toHaveBeenCalledTimes(1);
+
+    unregister();
+
+    expect(listener).toHaveBeenCalledTimes(2);
+
+    unsubscribe();
+  });
+
+  it("lets a listener see the action it was told about", () => {
+    let seen: string[] = [];
+
+    const unsubscribe = uiActionsRegistry.subscribe(() => {
+      seen = uiActionsRegistry
+        .getActions("late-action", { id: "e1" } as any)
+        .map((item) => item.identifier);
+    });
+
+    const unregister = uiActionsRegistry.registerAction("late-action", value);
+
+    expect(seen).toEqual(["late-action"]);
+
+    unregister();
+    unsubscribe();
+  });
+
+  it("stops calling a listener once unsubscribed", () => {
+    const listener = jest.fn();
+
+    uiActionsRegistry.subscribe(listener)();
+
+    uiActionsRegistry.registerAction("another-action", value)();
+
+    expect(listener).not.toHaveBeenCalled();
+  });
+
+  it("survives a listener that unsubscribes itself while being notified", () => {
+    const other = jest.fn();
+
+    const unsubscribeOther = uiActionsRegistry.subscribe(other);
+
+    const unsubscribeSelf = uiActionsRegistry.subscribe(() => {
+      unsubscribeSelf();
+    });
+
+    expect(() =>
+      uiActionsRegistry.registerAction("self-removing", value)()
+    ).not.toThrow();
+
+    expect(other).toHaveBeenCalled();
+
+    unsubscribeOther();
+  });
+});
+
+describe("isActionAvailableFor", () => {
+  const entry = { id: "e1" } as any;
+
+  it("shows an action that states no opinion", () => {
+    expect(isActionAvailableFor({ invokeAction: jest.fn() }, entry)).toBe(true);
+  });
+
+  it.each([
+    ["isSupportDownloads"],
+    ["isActionSupported"],
+    ["isActionAvailable"],
+  ])("honours %s", (predicate) => {
+    expect(
+      isActionAvailableFor(
+        { invokeAction: jest.fn(), [predicate]: () => false } as any,
+        entry
+      )
+    ).toBe(false);
+  });
+
+  it("asks only the first predicate the action defines", () => {
+    const isActionAvailable = jest.fn(() => true);
+
+    expect(
+      isActionAvailableFor(
+        {
+          invokeAction: jest.fn(),
+          isSupportDownloads: () => false,
+          isActionAvailable,
+        } as any,
+        entry
+      )
+    ).toBe(false);
+
+    expect(isActionAvailable).not.toHaveBeenCalled();
+  });
+
+  it("treats a missing action as unavailable-free", () => {
+    expect(isActionAvailableFor(undefined, entry)).toBe(true);
+  });
+});

package/uiActionsRegistrator/__tests__/usableActionItems.test.ts

@@ -0,0 +1,52 @@
+import { usableActionItems } from "../usableActionItems";
+
+const action = (identifier: string) =>
+  ({ identifier, action: { invokeAction: jest.fn() } }) as any;
+
+describe("usableActionItems", () => {
+  it("keeps a usable list untouched, in order", () => {
+    const base = [action("share"), action("favorites")];
+
+    expect(usableActionItems(base).map((item) => item.identifier)).toEqual([
+      "share",
+      "favorites",
+    ]);
+  });
+
+  it("keeps the first of a repeated identifier", () => {
+    const firstShare = action("share");
+    const secondShare = action("share");
+
+    const result = usableActionItems([
+      firstShare,
+      action("favorites"),
+      secondShare,
+    ]);
+
+    expect(result.map((item) => item.identifier)).toEqual([
+      "share",
+      "favorites",
+    ]);
+
+    expect(result[0]).toBe(firstShare);
+  });
+
+  it("drops items that cannot be invoked or have no identifier", () => {
+    const result = usableActionItems([
+      action("share"),
+      { identifier: "blank" } as any,
+      { identifier: "no-invoke", action: {} } as any,
+      { action: { invokeAction: jest.fn() } } as any,
+      action("entry_action_0"),
+    ]);
+
+    expect(result.map((item) => item.identifier)).toEqual([
+      "share",
+      "entry_action_0",
+    ]);
+  });
+
+  it("tolerates a missing list", () => {
+    expect(usableActionItems(undefined as any)).toEqual([]);
+  });
+});

package/uiActionsRegistrator/index.ts

@@ -0,0 +1,25 @@
+export {
+  canRenderActionIcon,
+  resolveActionAsset,
+  isActionAvailableFor,
+  observeEntryState,
+  uiActionsRegistry,
+} from "./registry";
+
+export type {
+  RegisteredAction,
+  RegisteredActionSource,
+  RegisteredActionValue,
+  RegistryChangeListener,
+  UIActionProvider,
+} from "./registry";
+
+export { usableActionItems } from "./usableActionItems";
+
+export {
+  ENTRY_ACTIONS_IDENTIFIER,
+  parseActionIdentifiers,
+  resolveActionIdentifiers,
+} from "./resolveActionIdentifiers";
+
+export type { ResolveActionIdentifiersParams } from "./resolveActionIdentifiers";