@applicaster/zapp-react-native-utils 15.0.0-alpha.3514407021 → 15.0.0-alpha.3564837831

package/reactHooks/feed/__tests__/{useInflatedUrl.test.ts → useInflatedUrl.test.tsx}

@@ -1,3 +1,34 @@
+import React from "react";
+
+import { WrappedWithProviders } from "@applicaster/zapp-react-native-utils/testUtils";
+
+import {
+  getInflatedDataSourceUrl,
+  getSearchContext,
+  useGetUrlInflater,
+} from "../useInflatedUrl";
+
+import { reactHooksLogger } from "../../logger";
+
+jest.mock("../../navigation", () => ({
+  useRoute: () => ({ pathname: "/mock/path" }),
+}));
+
+// mock contexts hooks
+jest.mock("@applicaster/zapp-react-native-ui-components/Contexts", () => ({
+  ZappPipesEntryContext: {
+    useZappPipesContext: () => [
+      { id: "entry-1", extensions: { showId: "A123" } },
+    ],
+  },
+  ZappPipesSearchContext: {
+    useZappPipesContext: () => ["user%20query"],
+  },
+  ZappPipesScreenContext: {
+    useZappPipesContext: () => [{ id: "screen-1" }],
+  },
+}));
+
 jest.mock("../../logger", () => ({
   reactHooksLogger: {
     warning: jest.fn(),
@@ -5,13 +36,6 @@ jest.mock("../../logger", () => ({
   },
 }));
 
-const {
-  getInflatedDataSourceUrl,
-  getSearchContext,
-} = require("../useInflatedUrl");
-
-const { reactHooksLogger } = require("../../logger");
-
 let mockStore;
 
 describe("getInflatedDataSourceUrl", () => {
@@ -188,3 +212,34 @@ describe("getSearchContext", () => {
     expect(result).toHaveProperty(mapping.queryParam.property, searchContext);
   });
 });
+
+describe("useGetUrlInflater", () => {
+  const { renderHook } = require("@testing-library/react-hooks");
+
+  it("returns original url when mapping is not provided", () => {
+    const { result } = renderHook(() => useGetUrlInflater(), {
+      wrapper: WrappedWithProviders,
+    });
+
+    const src = "https://foo.com/feed";
+    expect(result.current(src)).toBe(src);
+  });
+
+  it("inflates url using entry/search/screen contexts when mapping provided", () => {
+    const { result } = renderHook(() => useGetUrlInflater(), {
+      wrapper: ({ children }) => (
+        <WrappedWithProviders>{children}</WrappedWithProviders>
+      ),
+    });
+
+    const source = "https://foo.com/shows/{{showId}}?q={{q}}";
+
+    const mapping = {
+      showId: { source: "entry", property: "extensions.showId" },
+      q: { source: "search", property: "q" },
+    };
+
+    const url = result.current(source, mapping);
+    expect(url).toBe("https://foo.com/shows/A123?q=user%20query");
+  });
+});

package/reactHooks/feed/useEntryScreenId.ts

@@ -1,7 +1,7 @@
-import { usePickFromState } from "@applicaster/zapp-react-native-redux/hooks";
+import { useContentTypes } from "@applicaster/zapp-react-native-redux";
 
 export const useEntryScreenId = (entry?: ZappEntry): string | undefined => {
-  const { contentTypes } = usePickFromState("contentTypes");
+  const contentTypes = useContentTypes();
 
   if (!entry) {
     return;

package/reactHooks/feed/useInflatedUrl.ts

@@ -1,4 +1,4 @@
-import { useMemo } from "react";
+import { useCallback, useMemo, useRef } from "react";
 import * as R from "ramda";
 
 import {
@@ -169,7 +169,7 @@ const encodeIfNeeded: (string) => string = R.tryCatch(
 
 export function getSearchContext(
   searchContext: string,
-  mapping: ZappTypeMapping
+  mapping: Nullable<ZappTypeMapping>
 ) {
   if (!mapping) {
     return {};
@@ -183,31 +183,57 @@ export function getSearchContext(
   return { [property]: encodeIfNeeded(searchContext) };
 }
 
-export function useInflatedUrl({
-  feedUrl,
-  mapping,
-}: {
-  feedUrl?: string;
-  mapping?: ZappTypeMapping;
-}) {
+/**
+ * Hook returns a function that replace placeholders with context values
+ * @returns function that inflates urls based on contexts
+ */
+export const useGetUrlInflater = () => {
   const { pathname } = useRoute();
 
   const [entryContext] = ZappPipesEntryContext.useZappPipesContext(pathname);
   const [searchContext] = ZappPipesSearchContext.useZappPipesContext();
   const [screenContext] = ZappPipesScreenContext.useZappPipesContext();
 
-  const url = useMemo(
-    () =>
-      getInflatedDataSourceUrl({
+  const entryContextRef = useRef(entryContext);
+  entryContextRef.current = entryContext;
+
+  const screenContextRef = useRef(screenContext);
+  screenContextRef.current = screenContext;
+
+  const searchContextRef = useRef(searchContext);
+  searchContextRef.current = searchContext;
+
+  return useCallback(
+    (
+      feedUrl: Nullable<string>,
+      mapping?: Nullable<ZappTypeMapping>
+    ): Nullable<string> => {
+      return getInflatedDataSourceUrl({
         source: feedUrl,
         contexts: {
-          entry: entryContext,
-          screen: screenContext,
-          search: getSearchContext(searchContext, mapping),
+          entry: entryContextRef.current,
+          screen: screenContextRef.current,
+          search: getSearchContext(searchContextRef.current, mapping),
         },
         mapping,
-      }),
-    [entryContext, feedUrl, mapping, screenContext, searchContext]
+      });
+    },
+    []
+  );
+};
+
+export function useInflatedUrl({
+  feedUrl,
+  mapping,
+}: {
+  feedUrl?: string;
+  mapping?: ZappTypeMapping;
+}) {
+  const urlInflater = useGetUrlInflater();
+
+  const url = useMemo(
+    () => urlInflater(feedUrl, mapping),
+    [urlInflater, feedUrl, mapping]
   );
 
   return url;

package/reactHooks/flatList/useLoadNextPageIfNeeded.ts

@@ -1,10 +1,8 @@
 import { noop } from "@applicaster/zapp-react-native-utils/functionUtils";
 import React from "react";
 
-type Return = (index: number) => void;
-
 type Predicate = (
-  entry: ZappUIComponentProps["zappPipesData"]["data"]["entry"],
+  entryLength: number,
   index: number,
   numberOfColumns: number
 ) => boolean;
@@ -12,19 +10,15 @@ type Predicate = (
 type Props = {
   ifNeeded: Predicate;
   loadNextData: () => void;
-  entry: ZappUIComponentProps["zappPipesData"]["data"]["entry"];
+  entryLength: number;
   numberOfColumns?: number;
 };
 
 const handleLoadNextPage =
   (
-    ifNeeded: (
-      entry: ZappEntry[],
-      index: number,
-      numberOfColumns?: number
-    ) => boolean,
+    ifNeeded: Predicate,
     loadNextData: () => void,
-    entry: ZappEntry[],
+    entryLength: number,
     numberOfColumns
   ) =>
   (index: number) => {
@@ -32,7 +26,7 @@ const handleLoadNextPage =
      * Lazy-Loading, invoke nextLoadData if we reach the end of the List
      */
 
-    if (ifNeeded(entry, index, numberOfColumns)) {
+    if (ifNeeded(entryLength, index, numberOfColumns)) {
       loadNextData();
     }
   };
@@ -40,11 +34,14 @@ const handleLoadNextPage =
 export const useLoadNextPageIfNeeded = ({
   ifNeeded,
   loadNextData = noop,
-  entry,
+  entryLength,
   numberOfColumns = 0,
-}: Props): Return => {
-  return React.useCallback(
-    handleLoadNextPage(ifNeeded, loadNextData, entry, numberOfColumns),
-    [ifNeeded, loadNextData, entry, numberOfColumns]
+}: Props) => {
+  const memoFn = React.useMemo(
+    () =>
+      handleLoadNextPage(ifNeeded, loadNextData, entryLength, numberOfColumns),
+    [ifNeeded, loadNextData, entryLength, numberOfColumns]
   );
+
+  return memoFn;
 };

package/reactHooks/layout/index.ts

@@ -44,7 +44,7 @@ export function useStatusBarHeight() {
 
   return platformSelect({
     ios: StatusBarHeight,
-    android: StatusBar.currentHeight,
+    android: StatusBar.currentHeight ?? 0,
     default: 0,
   });
 }

package/reactHooks/layout/useDimensions/__tests__/{useDimensions.test.ts → useDimensions.test.tsx}

@@ -1,16 +1,10 @@
-import { renderHook } from "@testing-library/react-hooks";
+import React from "react";
+import { renderHook } from "@testing-library/react-native";
 import { Dimensions, StatusBar } from "react-native";
 import { useDimensions } from "../useDimensions";
-import { usePickFromState } from "@applicaster/zapp-react-native-redux";
 
 import { useIsScreenActive } from "@applicaster/zapp-react-native-utils/reactHooks/navigation/useIsScreenActive";
-
-jest.mock("@applicaster/zapp-react-native-redux/hooks", () => {
-  return {
-    ...jest.requireActual("@applicaster/zapp-react-native-redux/hooks"),
-    usePickFromState: jest.fn(),
-  };
-});
+import { WrappedWithProviders } from "@applicaster/zapp-react-native-utils/testUtils";
 
 jest.mock(
   "@applicaster/zapp-react-native-utils/reactHooks/navigation/useIsScreenActive",
@@ -42,12 +36,22 @@ describe("useDimensions", () => {
 
   beforeEach(() => {
     StatusBar.currentHeight = 20;
-    (usePickFromState as jest.Mock).mockReturnValue({ appData: mockAppData });
   });
 
   it("returns correct initial dimensions", () => {
-    const { result } = renderHook(() =>
-      useDimensions("window", { fullDimensions: false })
+    const { result } = renderHook(
+      () => useDimensions("window", { fullDimensions: false }),
+      {
+        wrapper: ({ children }) => (
+          <WrappedWithProviders
+            store={{
+              appData: mockAppData,
+            }}
+          >
+            {children}
+          </WrappedWithProviders>
+        ),
+      }
     );
 
     expect(result.current).toMatchObject({
@@ -56,7 +60,17 @@ describe("useDimensions", () => {
   });
 
   it("calls handler on mount", () => {
-    renderHook(() => useDimensions("window", { fullDimensions: false }));
+    renderHook(() => useDimensions("window", { fullDimensions: false }), {
+      wrapper: ({ children }) => (
+        <WrappedWithProviders
+          store={{
+            appData: mockAppData,
+          }}
+        >
+          {children}
+        </WrappedWithProviders>
+      ),
+    });
 
     expect(Dimensions.addEventListener).toHaveBeenCalledWith(
       "change",
@@ -65,12 +79,23 @@ describe("useDimensions", () => {
   });
 
   it("calls handler on isActive change", () => {
-    const { rerender } = renderHook(() =>
-      useDimensions("window", { fullDimensions: false })
+    const { rerender } = renderHook(
+      () => useDimensions("window", { fullDimensions: false }),
+      {
+        wrapper: ({ children }) => (
+          <WrappedWithProviders
+            store={{
+              appData: mockAppData,
+            }}
+          >
+            {children}
+          </WrappedWithProviders>
+        ),
+      }
     );
 
     (useIsScreenActive as jest.Mock).mockReturnValue(false);
-    rerender();
+    rerender({});
 
     expect(Dimensions.addEventListener).toHaveBeenCalledWith(
       "change",
@@ -79,8 +104,19 @@ describe("useDimensions", () => {
   });
 
   it("handles fullDimensions option", () => {
-    const { result } = renderHook(() =>
-      useDimensions("window", { fullDimensions: true })
+    const { result } = renderHook(
+      () => useDimensions("window", { fullDimensions: true }),
+      {
+        wrapper: ({ children }) => (
+          <WrappedWithProviders
+            store={{
+              appData: mockAppData,
+            }}
+          >
+            {children}
+          </WrappedWithProviders>
+        ),
+      }
     );
 
     expect(result.current).toMatchObject({
@@ -91,8 +127,19 @@ describe("useDimensions", () => {
   });
 
   it("handles excludeStatusBar option", () => {
-    const { result } = renderHook(() =>
-      useDimensions("window", { excludeStatusBar: true })
+    const { result } = renderHook(
+      () => useDimensions("window", { excludeStatusBar: true }),
+      {
+        wrapper: ({ children }) => (
+          <WrappedWithProviders
+            store={{
+              appData: mockAppData,
+            }}
+          >
+            {children}
+          </WrappedWithProviders>
+        ),
+      }
     );
 
     expect(result.current.height).toBe(
@@ -101,8 +148,19 @@ describe("useDimensions", () => {
   });
 
   it("handles rounded option", () => {
-    const { result } = renderHook(() =>
-      useDimensions("window", { rounded: true })
+    const { result } = renderHook(
+      () => useDimensions("window", { rounded: true }),
+      {
+        wrapper: ({ children }) => (
+          <WrappedWithProviders
+            store={{
+              appData: mockAppData,
+            }}
+          >
+            {children}
+          </WrappedWithProviders>
+        ),
+      }
     );
 
     expect(result.current.width).toBe(Math.ceil(mockDimensions.width));
@@ -110,8 +168,19 @@ describe("useDimensions", () => {
   });
 
   it("handles deviceInfo option", () => {
-    const { result } = renderHook(() =>
-      useDimensions("window", { deviceInfo: true })
+    const { result } = renderHook(
+      () => useDimensions("window", { deviceInfo: true }),
+      {
+        wrapper: ({ children }) => (
+          <WrappedWithProviders
+            store={{
+              appData: mockAppData,
+            }}
+          >
+            {children}
+          </WrappedWithProviders>
+        ),
+      }
     );
 
     expect(result.current.deviceInfo).toMatchObject({
@@ -121,7 +190,18 @@ describe("useDimensions", () => {
 
   it("logs deprecation warning when fullDimensions is boolean", () => {
     const consoleWarnSpy = jest.spyOn(console, "warn").mockImplementation();
-    renderHook(() => useDimensions("window", true));
+
+    renderHook(() => useDimensions("window", true), {
+      wrapper: ({ children }) => (
+        <WrappedWithProviders
+          store={{
+            appData: mockAppData,
+          }}
+        >
+          {children}
+        </WrappedWithProviders>
+      ),
+    });
 
     expect(consoleWarnSpy).toHaveBeenCalledWith(
       "Deprecation Warning\nSecond argument is now the options object. {fullDimensions: boolean, ...}"

package/reactHooks/layout/useDimensions/useDimensions.ts

@@ -3,7 +3,7 @@ import { useLayoutEffect, useMemo, useRef, useState } from "react";
 import * as R from "ramda";
 
 import { Dimensions, Platform, StatusBar } from "react-native";
-import { usePickFromState } from "@applicaster/zapp-react-native-redux/hooks";
+import { useAppData } from "@applicaster/zapp-react-native-redux/hooks";
 
 import { isTV } from "../../../reactUtils";
 
@@ -37,7 +37,7 @@ export const useDimensions: UseDimensions = (
 ) => {
   const statusBarHeight = StatusBar?.currentHeight;
   const isActive = useIsScreenActive();
-  const { appData } = usePickFromState(["appData"]);
+  const appData = useAppData();
 
   if (typeof fullDimensions === "boolean") {
     // eslint-disable-next-line no-console

package/reactHooks/navigation/index.ts

@@ -3,7 +3,7 @@ import { BackHandler } from "react-native";
 
 import {
   useContentTypes,
-  usePickFromState,
+  usePlugins,
 } from "@applicaster/zapp-react-native-redux/hooks";
 import { HooksManager } from "@applicaster/zapp-react-native-utils/appUtils/HooksManager";
 
@@ -16,6 +16,8 @@ import { useConnectionInfo } from "../connection";
 
 import { isTV, isWeb } from "@applicaster/zapp-react-native-utils/reactUtils";
 import { useNavbarState } from "../screen";
+import { useRivers } from "../state";
+import { useLayoutVersion } from "../layout";
 
 export { useNavigation } from "./useNavigation";
 
@@ -86,6 +88,10 @@ export function isNavBarVisible(
   if (route.startsWith("/hooks/")) {
     const module = screenData?.module;
 
+    if (module === undefined) {
+      return showNavBar;
+    }
+
     if (module?.presentFullScreen) {
       return false;
     }
@@ -164,11 +170,10 @@ export const useZappHooksForEntry = (
     setIsRunningInBackground,
   }: HookModalContextT = useContext(ZappHookModalContext.ReactContext);
 
-  const {
-    appData: { layoutVersion },
-    rivers,
-    plugins,
-  } = usePickFromState(["appData", "rivers", "plugins"]);
+  const plugins = usePlugins();
+  const rivers = useRivers();
+
+  const layoutVersion = useLayoutVersion();
 
   const contentTypes = useContentTypes();
 

package/reactHooks/navigation/useRoute.ts

@@ -3,7 +3,10 @@
 
 import { useContext } from "react";
 
-import { usePickFromState } from "@applicaster/zapp-react-native-redux/hooks";
+import {
+  useContentTypes,
+  usePlugins,
+} from "@applicaster/zapp-react-native-redux/hooks";
 
 import { legacyScreenData } from "@applicaster/quick-brick-core/App/NavigationProvider/utils";
 
@@ -14,6 +17,7 @@ import { useNavigation } from "./useNavigation";
 import { useModalStoreState } from "../../modalState";
 import { ScreenDataContext } from "@applicaster/zapp-react-native-ui-components/Contexts/ScreenDataContext";
 import { usePathname } from "./usePathname";
+import { useRivers } from "../state";
 
 // starts with modal/
 const isModalPathname = (pathname: string) => /^modal\//.test(pathname);
@@ -42,11 +46,9 @@ export const useRoute = (
     ? legacyScreenData(screenContext)
     : screenContext;
 
-  const { plugins, contentTypes, rivers } = usePickFromState([
-    "plugins",
-    "rivers",
-    "contentTypes",
-  ]);
+  const plugins = usePlugins();
+  const rivers = useRivers();
+  const contentTypes = useContentTypes();
 
   const modalState = useModalStoreState();
 

package/reactHooks/player/TVSeekControlller/TVSeekController.ts

@@ -147,17 +147,34 @@ export class TVSeekController
 
     let targetPos = currentPos;
 
-    if (this.currentSeekType === SEEK_TYPE.FORWARD) {
-      targetPos = Math.min(
-        currentPos + offset,
-        this.playerController.getSeekableDuration()
-      );
-    } else if (this.currentSeekType === SEEK_TYPE.REWIND) {
-      targetPos = Math.max(0, currentPos - offset);
+    const isLive = this.playerController.isLive();
+
+    if (isLive) {
+      if (this.currentSeekType === SEEK_TYPE.REWIND) {
+        targetPos = Math.min(
+          currentPos + offset,
+          this.playerController.getSeekableDuration()
+        );
+      } else if (this.currentSeekType === SEEK_TYPE.FORWARD) {
+        targetPos = Math.max(0, currentPos - offset);
+      } else {
+        log_warning(
+          `TVSeekController: handleDelayedSeek - invalid seek type: ${this.currentSeekType}`
+        );
+      }
     } else {
-      log_warning(
-        `TVSeekController: handleDelayedSeek - invalid seek type: ${this.currentSeekType}`
-      );
+      if (this.currentSeekType === SEEK_TYPE.FORWARD) {
+        targetPos = Math.min(
+          currentPos + offset,
+          this.playerController.getSeekableDuration()
+        );
+      } else if (this.currentSeekType === SEEK_TYPE.REWIND) {
+        targetPos = Math.max(0, currentPos - offset);
+      } else {
+        log_warning(
+          `TVSeekController: handleDelayedSeek - invalid seek type: ${this.currentSeekType}`
+        );
+      }
     }
 
     log_debug(

package/reactHooks/resolvers/useCellResolver.ts

@@ -3,7 +3,10 @@ import memoizee from "memoizee";
 import * as R from "ramda";
 
 import { CellRendererResolver } from "@applicaster/zapp-react-native-ui-components/Components/CellRendererResolver";
-import { usePickFromState } from "@applicaster/zapp-react-native-redux/hooks";
+import {
+  usePlugins,
+  useCellStyles,
+} from "@applicaster/zapp-react-native-redux";
 import { useDimensions } from "../layout";
 import { useIsRTL } from "../../localizationUtils";
 
@@ -53,7 +56,8 @@ export function useCellResolver({
     updateForInactiveScreens: false,
   });
 
-  const { plugins, cellStyles } = usePickFromState(["plugins", "cellStyles"]);
+  const plugins = usePlugins();
+  const cellStyles = useCellStyles();
   const isRTL = useIsRTL();
 
   const options = {

package/reactHooks/resolvers/useComponentResolver.ts

@@ -2,7 +2,11 @@
 import * as React from "react";
 
 import { findComponentByType } from "@applicaster/zapp-react-native-utils/pluginUtils";
-import { usePickFromState } from "@applicaster/zapp-react-native-redux/hooks";
+import {
+  usePlugins,
+  useAppSelector,
+  selectComponents,
+} from "@applicaster/zapp-react-native-redux";
 
 type Decorator = (component: React.Component<any>) => React.Component<any>;
 type Watcher = Array<any>;
@@ -15,7 +19,9 @@ export function useComponentResolver(
   { componentType, decorators }: Props,
   watchers?: Watcher
 ): React.ComponentType<any> {
-  const { plugins, components } = usePickFromState(["plugins", "components"]);
+  const plugins = usePlugins();
+
+  const components = useAppSelector(selectComponents);
 
   return React.useMemo(
     () =>

package/reactHooks/screen/__tests__/useCurrentScreenData.test.tsx

@@ -2,7 +2,7 @@ import * as React from "react";
 import { Provider } from "react-redux";
 import { renderHook } from "@testing-library/react-hooks";
 import configureStore from "redux-mock-store";
-import thunk from "redux-thunk";
+import { thunk } from "redux-thunk";
 
 const mockStore = configureStore([thunk]);
 

package/reactHooks/screen/__tests__/useTargetScreenData.test.tsx

@@ -2,15 +2,23 @@ import * as React from "react";
 import { Provider } from "react-redux";
 import { renderHook } from "@testing-library/react-hooks";
 import configureStore from "redux-mock-store";
-import thunk from "redux-thunk";
+import { thunk } from "redux-thunk";
 
 const mockStore = configureStore([thunk]);
 
 import { useTargetScreenData } from "../useTargetScreenData";
 
 describe("useTargetScreenData", function () {
-  const river_id_2 = {};
-  const river_id_1 = {};
+  const river_id_2 = {
+    id: "river_id_2",
+    type: "any",
+  };
+
+  const river_id_1 = {
+    id: "river_id_1",
+    type: "any",
+  };
+
   const screenId = "river_id_2";
   const entry = { id: "test", type: { value: "video" } };