@applicaster/zapp-react-native-utils 12.0.0-alpha.4201443043 → 12.0.0-alpha.4223432180

package/reactHooks/feed/useBatchLoading.ts

@@ -45,19 +45,23 @@ const filterEmptyData = (data) => {
   return true;
 };
 
-const extractData = compose(uniq, map(dataOf));
+const getData = (rawData) =>
+  rawData.component_type === "gallery-qb"
+    ? rawData.ui_components[0].data
+    : rawData.data;
+
+const extractData = compose(uniq, map(getData));
 
 export const allFeedsIsReady = (
   feeds: ZappPipesCollection,
   urls: (ZappDataSourceSource | null)[]
 ): boolean =>
-  urls
-    .filter(complement(isNil))
-    .map((url) => (url ? checkFeedIsReady(feeds[url]) : false))
-    .every(Boolean);
+  urls.every((url) =>
+    isNil(url) ? true : url && feeds[url] ? checkFeedIsReady(feeds[url]) : false
+  );
 
 export const useBatchLoading = (
-  data: { data?: ZappDataSource }[],
+  componentsToRender: { data?: ZappDataSource; component_type: string }[],
   options: Options
 ) => {
   const dispatch = useDispatch();
@@ -65,10 +69,18 @@ export const useBatchLoading = (
   const [searchContext] = ZappPipesSearchContext.useZappPipesContext();
   const [hasEverBeenReady, setHasEverBeenReady] = React.useState(false);
 
-  const takeBatchSize = take(
-    min(options.initialBatchSize ?? DEFAULT_BATCH_SIZE, data.length)
-  );
+  // if first component is gallery-qb, take only one component for initial load
+  const takeSize =
+    componentsToRender?.[0]?.component_type === "gallery-qb"
+      ? 1
+      : min(
+          options.initialBatchSize ?? DEFAULT_BATCH_SIZE,
+          componentsToRender.length
+        );
+
+  const takeBatchSize = React.useCallback(take(takeSize), [takeSize]);
 
+  // Prepare inflated url for datasource
   const getUrl = React.useCallback(
     (data) => {
       const mappedFeed = data.mapping
@@ -88,13 +100,16 @@ export const useBatchLoading = (
     [entryContext, screenContext, searchContext]
   );
 
-  const batchData = takeBatchSize(data);
+  // components for initial load
+  const batchComponents = takeBatchSize(componentsToRender);
 
+  // contains datasources from batch components loading
   const feedData: ZappDataSource[] = React.useMemo(
-    () => extractData(batchData).filter(filterEmptyData),
-    [batchData]
+    () => extractData(batchComponents).filter(filterEmptyData),
+    [batchComponents]
   );
 
+  // contains inflated urls from batch components loading
   const feedUrls: ZappDataSourceSource[] = React.useMemo(
     () =>
       feedData.map((data) => {
@@ -102,34 +117,43 @@ export const useBatchLoading = (
 
         return mappedFeedUrl;
       }),
-    [] // No watchers as batch loaders is used only for initial load
+    []
   );
 
   const feeds = useZappPipesFeeds(feedUrls);
 
-  React.useEffect(() => {
-    const datasources = map(dataOf, batchData)
-      .filter(filterEmptyData)
-      .filter((data) => {
-        const feed = feeds[data.source];
+  // dispatch loadPipesData for each feed that is not loaded
+  const runBatchLoading = React.useCallback(() => {
+    batchComponents.forEach((rawData: any) => {
+      // 1. get data (dataOf)
 
-        if (!feed) return true;
+      const data = getData(rawData);
 
-        return !feedHasData(feed) && !feedIsLoading(feed);
-      });
+      // 2. filter out empty data filterEmptyData
+      if (!filterEmptyData(data)) return false;
 
-    datasources.forEach((data) => {
-      const mappedFeedUrl = getUrl(data);
+      // 3. filter out data that is already loaded (feeds[data.source]) &  !feedHasData(feed) && !feedIsLoading(feed);
+      const feed = feeds[data?.source];
 
-      if (mappedFeedUrl) {
-        return dispatch(
-          loadPipesData(mappedFeedUrl, { riverId: options.riverId })
-        );
+      if (!feed || (!feedHasData(feed) && !feedIsLoading(feed))) {
+        const mappedFeedUrl = getUrl(data);
+
+        if (mappedFeedUrl) {
+          // 4. load data
+          return dispatch(
+            loadPipesData(mappedFeedUrl, { riverId: options.riverId })
+          );
+        }
       }
     });
-  }, []); // No watchers as batch loaders is used only for initial load
+  }, [feedUrls]);
+
+  React.useEffect(() => {
+    runBatchLoading();
+  }, []);
 
   React.useEffect(() => {
+    // check if all feeds are ready and set hasEverBeenReady to true
     if (allFeedsIsReady(feeds, feedUrls) && !hasEverBeenReady) {
       setHasEverBeenReady(true);
     }

package/reactHooks/feed/useFeedRefresh.tsx

@@ -1,7 +1,8 @@
 import * as React from "react";
-import * as R from "ramda";
+import { path, max } from "ramda";
 import { isTrue } from "@applicaster/zapp-react-native-utils/booleanUtils";
 import { toNumberWithDefault } from "@applicaster/zapp-react-native-utils/numberUtils";
+import { useIsScreenActive } from "@applicaster/zapp-react-native-utils/reactHooks/navigation";
 
 import { reactHooksLogger } from "../logger";
 import { ReloadDataFunction } from "./useFeedLoader";
@@ -18,9 +19,8 @@ const minimumRefreshingInterval = 5;
 const defaultRefreshInterval = 60;
 
 export const useFeedRefresh = ({ reloadData, component }: Props): void => {
-  const enable_data_refreshing = R.path(
-    ["rules", "enable_data_refreshing"],
-    component
+  const isDataRefreshingEnabled = isTrue(
+    path(["rules", "enable_data_refreshing"], component)
   );
 
   const refreshing_interval = toNumberWithDefault(
@@ -29,10 +29,12 @@ export const useFeedRefresh = ({ reloadData, component }: Props): void => {
   );
 
   const refreshingIntervalInMilliseconds =
-    R.max(refreshing_interval, minimumRefreshingInterval) * 1000;
+    max(refreshing_interval, minimumRefreshingInterval) * 1000;
+
+  const isScreenActive = useIsScreenActive();
 
   React.useEffect(() => {
-    if (isTrue(enable_data_refreshing) && refreshing_interval) {
+    if (isDataRefreshingEnabled && refreshing_interval && isScreenActive) {
       if (refreshing_interval < minimumRefreshingInterval) {
         feedRefreshLogger.warning({
           message: `You set your feed refresh interval to ${refreshing_interval} when minimum value is ${minimumRefreshingInterval}seconds.Your feed will refresh after ${minimumRefreshingInterval}seconds.`,
@@ -59,5 +61,5 @@ export const useFeedRefresh = ({ reloadData, component }: Props): void => {
         clearInterval(refreshInterval);
       };
     }
-  }, [reloadData]);
+  }, [reloadData, isScreenActive]);
 };

package/reactHooks/layout/useDimensions/__tests__/useDimensions.test.ts

@@ -0,0 +1,134 @@
+import { renderHook } from "@testing-library/react-hooks";
+import { Dimensions, StatusBar } from "react-native";
+
+const mockUsePickFromState = jest.fn();
+const mockUseIsScreenActive = jest.fn();
+const mockGetInitialDimensions = jest.fn();
+const mockGetDeviceInfo = jest.fn();
+
+jest.mock("@applicaster/zapp-react-native-redux/hooks", () => ({
+  ...(jest.requireActual("@applicaster/zapp-react-native-redux/hooks") as {}),
+  usePickFromState: mockUsePickFromState,
+}));
+
+jest.mock("../../../navigation", () => ({
+  useIsScreenActive: mockUseIsScreenActive,
+}));
+
+jest.mock("../helpers", () => ({
+  getInitialDimensions: mockGetInitialDimensions,
+}));
+
+jest.mock("../../getDeviceInfo", () => ({
+  getDeviceInfo: mockGetDeviceInfo,
+}));
+
+const { useDimensions } = require("../useDimensions");
+
+describe("useDimensions", () => {
+  const mockDimensions = { width: 100, height: 200, scale: 1, fontScale: 1 };
+  const mockAppData = { someData: "test" };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    Dimensions.get = jest.fn().mockReturnValue(mockDimensions);
+
+    Dimensions.addEventListener = jest.fn().mockReturnValue({
+      remove: jest.fn(),
+    });
+
+    mockUsePickFromState.mockReturnValue({ appData: mockAppData });
+    mockUseIsScreenActive.mockReturnValue(true);
+    mockGetInitialDimensions.mockReturnValue(mockDimensions);
+    mockGetDeviceInfo.mockReturnValue({ deviceInfo: "testDeviceInfo" });
+  });
+
+  it("returns correct initial dimensions", () => {
+    const { result } = renderHook(() =>
+      useDimensions("window", { fullDimensions: false })
+    );
+
+    expect(result.current).toEqual({
+      ...mockDimensions,
+      statusBarHeight: StatusBar.currentHeight,
+    });
+
+    expect(mockGetInitialDimensions).toHaveBeenCalledWith("window");
+  });
+
+  it("calls handler on mount", () => {
+    renderHook(() => useDimensions("window", { fullDimensions: false }));
+
+    expect(Dimensions.addEventListener).toHaveBeenCalledWith(
+      "change",
+      expect.any(Function)
+    );
+  });
+
+  it("calls handler on isActive change", () => {
+    const { rerender } = renderHook(() =>
+      useDimensions("window", { fullDimensions: false })
+    );
+
+    mockUseIsScreenActive.mockReturnValue(false);
+    rerender();
+
+    expect(Dimensions.addEventListener).toHaveBeenCalledWith(
+      "change",
+      expect.any(Function)
+    );
+  });
+
+  it("handles fullDimensions option", () => {
+    const { result } = renderHook(() =>
+      useDimensions("window", { fullDimensions: true })
+    );
+
+    expect(result.current).toEqual({
+      ...mockDimensions,
+      scale: 1,
+      fontScale: 1,
+      statusBarHeight: StatusBar.currentHeight,
+    });
+  });
+
+  it("handles excludeStatusBar option", () => {
+    const { result } = renderHook(() =>
+      useDimensions("window", { excludeStatusBar: true })
+    );
+
+    expect(result.current.height).toBe(
+      mockDimensions.height - StatusBar.currentHeight ?? 0
+    );
+  });
+
+  it("handles rounded option", () => {
+    const { result } = renderHook(() =>
+      useDimensions("window", { rounded: true })
+    );
+
+    expect(result.current.width).toBe(Math.ceil(mockDimensions.width));
+    expect(result.current.height).toBe(Math.ceil(mockDimensions.height));
+  });
+
+  it("handles deviceInfo option", () => {
+    const { result } = renderHook(() =>
+      useDimensions("window", { deviceInfo: true })
+    );
+
+    expect(result.current.deviceInfo).toMatchObject({
+      deviceInfo: "testDeviceInfo",
+    });
+  });
+
+  it("logs deprecation warning when fullDimensions is boolean", () => {
+    const consoleWarnSpy = jest.spyOn(console, "warn").mockImplementation();
+    renderHook(() => useDimensions("window", true));
+
+    expect(consoleWarnSpy).toHaveBeenCalledWith(
+      "Deprecation Warning\nSecond argument is now the options object. {fullDimensions: boolean, ...}"
+    );
+
+    consoleWarnSpy.mockRestore();
+  });
+});

package/reactHooks/layout/useDimensions/useDimensions.ts

@@ -95,6 +95,8 @@ export const useDimensions: UseDimensions = (
 
     const activeSubscription = Dimensions.addEventListener("change", handler);
 
+    handler({ [context]: Dimensions.get(context) });
+
     return () => {
       activeSubscription.remove();
     };

package/reactHooks/navigation/index.ts

@@ -4,7 +4,6 @@
 import React, { useContext, useEffect, useMemo } from "react";
 import { BackHandler, InteractionManager, NativeModules } from "react-native";
 import { useSafeAreaInsets } from "react-native-safe-area-context";
-import { isEmpty } from "ramda";
 
 import {
   useContentTypes,
@@ -18,7 +17,7 @@ import {
   QUICK_BRICK_NAVBAR,
   QUICK_BRICK_CONTENT,
 } from "@applicaster/quick-brick-core/const";
-import { useZappHooksModalState } from "@applicaster/zapp-react-dom-ui-components/Components/ZappHooksModal/ZappHooksModal";
+import { useZappHooksModalState } from "@applicaster/zapp-react-dom-ui-components/Components/ZappHooksModal/hooks/useZappHooksModalState";
 import { ZappHookModalContext } from "@applicaster/zapp-react-native-ui-components/Contexts";
 import { PathnameContext } from "@applicaster/zapp-react-native-ui-components/Contexts/PathnameContext";
 import { HookModalContextT } from "@applicaster/zapp-react-native-ui-components/Contexts/ZappHookModalContext";
@@ -32,7 +31,7 @@ import { platformSelect } from "../../reactUtils";
 import { useConnectionInfo } from "../connection";
 import { getTargetScreenData } from "../screen/useTargetScreenData";
 
-import { isTV } from "@applicaster/zapp-react-native-utils/reactUtils";
+import { isTV, isWeb } from "@applicaster/zapp-react-native-utils/reactUtils";
 import { useNavbarState } from "../screen";
 import { useNavigation } from "./useNavigation";
 import { useModalStore } from "../../modalState";
@@ -79,6 +78,10 @@ export function isNavBarVisible(
     return false;
   }
 
+  if (screenData?.plugin_type === "login" && isTV()) {
+    return false;
+  }
+
   /* Match if screen is Hook */
   if (route.startsWith("/hooks/")) {
     const module = screenData?.module;
@@ -211,10 +214,7 @@ export const useRoute = (): {
     return { screenData: screenDataContext, pathname };
   }
 
-  // Cover cases where screenContext is used before navigation is initialized
-  const screenData = isEmpty(screenDataContext)
-    ? navigator.screenData
-    : screenDataContext;
+  const screenData = screenDataContext;
 
   return { screenData, pathname };
 };
@@ -466,7 +466,13 @@ export const useUniqueRouteSuffix = (): Return => {
   const suffix = `currentRoute:${currentRoute}_pathname:${pathname}`;
 
   const withUniqueRouteSuffix = React.useCallback((prefix: string) => {
-    return `${prefix}___${suffix}`;
+    if (isWeb()) {
+      // we should use extended route prefix only on Web, where we have stack-navigator
+      return `${prefix}___${suffix}`;
+    }
+
+    // for other platforms use previous version
+    return prefix;
   }, []);
 
   return withUniqueRouteSuffix;

package/reactHooks/player/useAutoSeek.tsx

@@ -1,5 +1,4 @@
 import React, { useEffect, useState } from "react";
-import * as R from "ramda";
 import { usePrevious } from "@applicaster/zapp-react-native-utils/reactHooks/utils";
 import { playerManager } from "@applicaster/zapp-react-native-utils/appUtils/playerManager";
 import {
@@ -17,10 +16,6 @@ export const useAutoSeek = (resetHUDTimer = noop) => {
   const intervalTimer = React.useRef(null);
   const prevRunning = usePrevious(isRunning);
 
-  const setIntervalTimer = (cb) => {
-    intervalTimer.current = setInterval(cb, ON_HOLD_INTERVAL);
-  };
-
   const clearIntervalTimer = () => {
     try {
       clearInterval(intervalTimer.current);
@@ -29,6 +24,11 @@ export const useAutoSeek = (resetHUDTimer = noop) => {
     }
   };
 
+  const setIntervalTimer = (cb) => {
+    clearIntervalTimer();
+    intervalTimer.current = setInterval(cb, ON_HOLD_INTERVAL);
+  };
+
   const resetState = () => {
     setIsRunning(false);
     setDirection(null);
@@ -42,7 +42,7 @@ export const useAutoSeek = (resetHUDTimer = noop) => {
     if (!player) return;
 
     if (direction) {
-      player[direction](R.min(MAX_SEEK_TIME, SKIP_TIME_BASE * multiplier));
+      player[direction](Math.min(MAX_SEEK_TIME, SKIP_TIME_BASE * multiplier));
       resetHUDTimer();
     }
   }, [multiplier, direction]);
@@ -50,7 +50,9 @@ export const useAutoSeek = (resetHUDTimer = noop) => {
   useEffect(() => {
     if (isRunning && isRunning !== prevRunning) {
       setIntervalTimer(() => {
-        setMultiplier(R.add(1));
+        setMultiplier((prev) => {
+          return prev + 1;
+        });
       });
     } else if (!isRunning && isRunning !== prevRunning) {
       resetState();

package/reactHooks/resolvers/useCellResolver.ts

@@ -48,7 +48,11 @@ export function useCellResolver({
   ...cellResolverOptions
 }: Props) {
   let _component = Object.assign({}, component);
-  const { width, height } = useDimensions("screen");
+
+  const { width, height } = useDimensions("screen", {
+    updateForInactiveScreens: false,
+  });
+
   const { plugins, cellStyles } = usePickFromState(["plugins", "cellStyles"]);
   const isRTL = useIsRTL();
 

package/reactHooks/useConfiguration.ts

@@ -67,7 +67,7 @@ export const useConfiguration = ({
       if (component) {
         const remappedStylesConfiguration = remapUpdatedKeys(
           pluginManifest,
-          component.styles
+          component
         );
 
         R.forEachObjIndexed((value, key) => {
@@ -83,7 +83,7 @@ export const useConfiguration = ({
 
         const styles = populateConfigurationValues(
           pluginManifest?.styles?.fields,
-          remappedStylesConfiguration,
+          remappedStylesConfiguration.styles,
           skipDefaults
         );
 

package/reactUtils/index.ts

@@ -108,3 +108,107 @@ export const isAndroidPlatform = () => Platform.OS === "android";
 export const isTvOSPlatform = () => getPlatform() === "tvos";
 
 export const isAndroidTVPlatform = () => getPlatform() === "android_tv";
+
+declare global {
+  interface Window {
+    VIZIO?: {
+      Chromevox: {
+        play: (text: string) => void;
+      };
+      exitApplication: () => void;
+      setClosedCaptionHandler: (
+        callback: (isCCEnabled: boolean) => void
+      ) => void;
+    };
+  }
+}
+
+/**
+ * Platforms found in userAgent string, please note that simulators
+ * might not have the same agents that the devices have
+ */
+export const PLATFORMS = {
+  webos: "Web0S",
+  tizen: "Tizen",
+  samsung: "SMART-TV",
+  mac: "Mac",
+  win: "Win",
+  linux: "Linux",
+  iphone: "iPhone",
+  android: "Android",
+  mobile: "Mobile",
+  vizio: "VIZIO",
+  smartcast: "SmartCast",
+  conjure: "Conjure",
+};
+
+/**
+ * Simple way of identifying if we have access to the tizen APIs
+ */
+export const hasTizen = typeof window?.tizen !== "undefined";
+
+/**
+ * Simple way of identifying if we have access to the webOS APIs
+ */
+export const hasWebOS = typeof window?.webOS !== "undefined";
+
+export const getUserAgent = () => window?.navigator?.userAgent;
+
+export const isLgPlatform = () => {
+  const userAgent = getUserAgent();
+
+  if (!userAgent) {
+    return false;
+  }
+
+  // Note: LG uses the number 0 in their userAgent, possibly because of Palm WebOS
+  return hasWebOS || userAgent.includes(PLATFORMS.webos);
+};
+
+export const isSamsungPlatform = () => {
+  const userAgent = getUserAgent();
+
+  if (!userAgent) {
+    return false;
+  }
+
+  return (
+    hasTizen ||
+    userAgent.includes(PLATFORMS.samsung) ||
+    userAgent.includes(PLATFORMS.tizen)
+  );
+};
+
+/**
+ * Checks if we are on the Vizio platform by using the userAgent string
+ *
+ * Use this method when you need to identify the platform on runtime
+ * before the VIZIO Companion Library has loaded
+ */
+export const isVizioPlatform = () => {
+  const userAgent = getUserAgent();
+
+  if (!userAgent) {
+    return false;
+  }
+
+  const isVizioAgent =
+    userAgent.includes(PLATFORMS.vizio) ||
+    userAgent.includes(PLATFORMS.smartcast) ||
+    userAgent.includes(PLATFORMS.conjure);
+
+  return isVizioAgent;
+};
+
+/**
+ * Checks if we are on the Vizio platform by checking for the global VIZIO object
+ * and the VIZIO Companion Library. This method does not use the userAgent string,
+ * because it mainly checks whether we have access to apis, which may not be available yet
+ */
+export const hasVizioAPIs = () => {
+  const hasAPIs =
+    typeof window.VIZIO !== "undefined" &&
+    window?.applicaster?.vizioLibraryDidLoad;
+
+  return hasAPIs;
+};

package/testUtils/index.tsx

@@ -7,9 +7,11 @@ import { Provider } from "react-redux";
 import thunk from "redux-thunk";
 import configureStore from "redux-mock-store";
 import { SafeAreaProvider } from "react-native-safe-area-context";
+import { appStore } from "@applicaster/zapp-react-native-redux/AppStore";
 
 import { render } from "@testing-library/react-native";
 import { AnalyticsProvider } from "../analyticsUtils";
+import { ThemeContext } from "../theme";
 
 export { getByTestId } from "./getByTestId";
 
@@ -59,7 +61,9 @@ const initialState = {
   appSettings: {},
   plugins: [],
   appState: { appReady: true, appLaunched: true },
+  pluginConfigurations: {},
   appData: { layoutVersion: "v1" },
+  zappPipes: {},
   contentTypes: null,
 };
 
@@ -68,20 +72,49 @@ export const WrappedWithProviders = ({
   store: storeObj = {},
 }: any) => {
   const _store = configureStore([thunk])(
-    R.mergeDeepWith(R.concat, { ...initialState }, storeObj)
+    R.mergeDeepRight(initialState, { ...storeObj })
   );
 
+  appStore.set(_store);
+
   return (
-    <SafeAreaProvider
-      initialMetrics={{
-        insets: { top: 0, left: 0, right: 0, bottom: 0 },
-        frame: { x: 0, y: 0, width: 0, height: 0 },
+    <ThemeContext.Provider
+      value={{
+        themes: {
+          light: {
+            component_margin_top: 0,
+            component_margin_bottom: 0,
+            component_margin_left: 0,
+            component_margin_right: 0,
+            component_padding_top: 0,
+            component_padding_bottom: 0,
+            component_padding_left: 0,
+            component_padding_right: 0,
+            component_gutter_vertical: 0,
+            component_gutter_horizontal: 0,
+            component_corner_radius: 0,
+            app_background_color: "rgba(0,0,0,0)",
+            screen_margin_top: 0,
+            screen_margin_bottom: 0,
+            component_anchor_point_y: 0,
+            assets: "",
+          },
+        },
+        selectedThemeId: "light",
+        setSelectedThemeId: () => {},
       }}
     >
-      <Provider store={_store}>
-        <AnalyticsProvider>{children}</AnalyticsProvider>
-      </Provider>
-    </SafeAreaProvider>
+      <SafeAreaProvider
+        initialMetrics={{
+          insets: { top: 0, left: 0, right: 0, bottom: 0 },
+          frame: { x: 0, y: 0, width: 0, height: 0 },
+        }}
+      >
+        <Provider store={_store}>
+          <AnalyticsProvider>{children}</AnalyticsProvider>
+        </Provider>
+      </SafeAreaProvider>
+    </ThemeContext.Provider>
   );
 };
 

package/appUtils/focusManager/FocusableEvents.ts

@@ -1,8 +0,0 @@
-export const FOCUSABLE_EVENTS = {
-  IS_REGISTERED: "isRegistered",
-  WILL_RECEIVE_FOCUS: "willReceiveFocus",
-  HAS_RECEIVED_FOCUS: "hasReceivedFocus",
-  WILL_LOSE_FOCUS: "willLoseFocus",
-  HAS_LOST_FOCUS: "hasLostFocus",
-  WILL_UNREGISTER: "willUnregister",
-};