@applicaster/zapp-react-native-utils 15.0.0-rc.5 → 15.0.0-rc.52

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";
 
@@ -164,11 +166,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__/useTargetScreenData.test.tsx

@@ -9,8 +9,16 @@ 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" } };
 

package/reactHooks/screen/useTargetScreenData.ts

@@ -1,7 +1,8 @@
 import React from "react";
-import { usePickFromState } from "@applicaster/zapp-react-native-redux/hooks";
+import { useContentTypes } from "@applicaster/zapp-react-native-redux/hooks";
 import * as R from "ramda";
 import { appStore } from "@applicaster/zapp-react-native-redux/AppStore";
+import { useRivers } from "../state";
 
 export function getTargetScreenData(
   entry: ZappEntry,
@@ -43,7 +44,8 @@ export function getTargetScreenDataFromEntry(entry: ZappEntry): ZappRiver {
 }
 
 export const useTargetScreenData = (entry: ZappEntry) => {
-  const { rivers, contentTypes } = usePickFromState(["rivers", "contentTypes"]);
+  const rivers = useRivers();
+  const contentTypes = useContentTypes();
 
   return React.useMemo(
     () => getTargetScreenData(entry, rivers, contentTypes),

package/reactHooks/state/useRivers.ts

@@ -3,6 +3,6 @@ import {
   selectRivers,
 } from "@applicaster/zapp-react-native-redux";
 
-export function useRivers(): Record<string, ZappRiver> {
+export function useRivers() {
   return useAppSelector(selectRivers);
 }

package/reactHooks/usePluginConfiguration.ts

@@ -1,7 +1,7 @@
 import * as R from "ramda";
 import { useMemo } from "react";
 
-import { usePickFromState } from "@applicaster/zapp-react-native-redux/hooks";
+import { usePlugins } from "@applicaster/zapp-react-native-redux/hooks";
 
 // importing this way prevents typescript packages importing from this
 // file to go crazy reporting errors on JS
@@ -25,7 +25,7 @@ export function parsePluginConfiguration(plugin, manifest) {
 }
 
 export function usePluginConfiguration<T, S>(identifier, manifest) {
-  const { plugins } = usePickFromState(["plugins"]);
+  const plugins = usePlugins();
 
   const plugin = useMemo(
     () => R.find(R.propEq("identifier", identifier), plugins),

package/testUtils/index.tsx

@@ -56,9 +56,29 @@ const initialState = {
   contentTypes: null,
 };
 
+const themeObjDefault = {
+  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: "",
+};
+
 export const WrappedWithProviders = ({
   children,
   store: storeObj = {},
+  theme: themeObj = themeObjDefault,
 }: any) => {
   const _store = configureStore([thunk])(
     R.mergeDeepRight(initialState, { ...storeObj })
@@ -70,24 +90,7 @@ export const WrappedWithProviders = ({
     <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: "",
-          },
+          light: themeObj,
         },
         selectedThemeId: "light",
         setSelectedThemeId: () => {},
@@ -113,11 +116,17 @@ export const WrappedWithProviders = ({
  * @param store optional store to pass to the provider
  * @returns
  */
-export const renderWithProviders = (component, storeObj?: unknown) => {
+export const renderWithProviders = (
+  component,
+  storeObj?: unknown,
+  themeObj?: unknown
+) => {
   return render(component, {
     wrapper: function TestWrapper({ children }: PropsWithChildren<any>) {
       return (
-        <WrappedWithProviders store={storeObj}>{children}</WrappedWithProviders>
+        <WrappedWithProviders store={storeObj} theme={themeObj}>
+          {children}
+        </WrappedWithProviders>
       );
     },
   });

package/utils/__tests__/mapAccum.test.ts

@@ -0,0 +1,73 @@
+import { mapAccum } from "../mapAccum";
+
+describe("mapAccum", () => {
+  it("using standard ramda test", () => {
+    const digits = ["1", "2", "3", "4"];
+    const appender = (a, b) => [a + b, a + b];
+
+    const [acc, result] = mapAccum(appender, 0, digits); //= > ['01234', ['01', '012', '0123', '01234']]
+    expect(acc).toBe("01234");
+    expect(result).toEqual(["01", "012", "0123", "01234"]);
+  });
+
+  it("maps and accumulates over an array", () => {
+    const fn = (acc, x) => [acc + x, x * 2];
+    const [acc, result] = mapAccum(fn, 0, [1, 2, 3]);
+
+    expect(acc).toBe(6); // final accumulator (0 + 1 + 2 + 3)
+    expect(result).toEqual([2, 4, 6]); // mapped values (acc + x*2 at each step)
+  });
+
+  it("returns initial accumulator for empty array", () => {
+    const fn = (acc, x) => [acc + x, acc * x];
+    const [acc, result] = mapAccum(fn, 10, []);
+
+    expect(acc).toBe(10);
+    expect(result).toEqual([]);
+  });
+
+  it("accumulates strings correctly", () => {
+    const fn = (acc, x) => [acc + x, acc + x];
+    const [acc, result] = mapAccum(fn, "A", ["B", "C", "D"]);
+
+    expect(acc).toBe("ABCD");
+    expect(result).toEqual(["AB", "ABC", "ABCD"]);
+  });
+
+  it("works with objects as accumulator", () => {
+    const fn = (acc, x) => {
+      const newAcc = { sum: acc.sum + x };
+
+      return [newAcc, newAcc.sum];
+    };
+
+    const [acc, result] = mapAccum(fn, { sum: 0 }, [1, 2, 3]);
+
+    expect(acc).toEqual({ sum: 6 });
+    expect(result).toEqual([1, 3, 6]);
+  });
+
+  it("is curried", () => {
+    const fn = (acc, x) => [acc + x, x * 2];
+    const mapWithFn = mapAccum(fn);
+    const withInit = mapWithFn(2);
+    const [acc, result] = withInit([1, 2, 3]);
+
+    expect(acc).toBe(8);
+    expect(result).toEqual([2, 4, 6]);
+  });
+
+  it("does not mutate the original array", () => {
+    const arr = [1, 2, 3];
+    mapAccum((acc, x) => [acc + x, acc + x], 0, arr);
+    expect(arr).toEqual([1, 2, 3]);
+  });
+
+  it("handles mixed types in accumulator and result", () => {
+    const fn = (acc, x) => [acc + x.length, acc + "-" + x];
+    const [acc, result] = mapAccum(fn, 0, ["a", "bb", "ccc"]);
+
+    expect(acc).toBe(6);
+    expect(result).toEqual(["0-a", "1-bb", "3-ccc"]);
+  });
+});