@applicaster/zapp-react-native-utils 12.0.0-rc.99 → 12.0.2-alpha.5400332623

package/reactHooks/feed/useFeedLoader.tsx

@@ -1,12 +1,11 @@
 import React, { useEffect } from "react";
-import { path } from "ramda";
 import { useDispatch } from "react-redux";
 
 import { loadPipesData } from "@applicaster/zapp-react-native-redux/ZappPipes";
 import { useZappPipesFeed } from "@applicaster/zapp-react-native-redux/hooks";
 
 import { reactHooksLogger } from "../logger";
-import { useIsInitialRender } from "../utils";
+import { useIsInitialRender, shouldDispatchData } from "../utils";
 import { useInflatedUrl } from "./useInflatedUrl";
 import { useRoute } from "../navigation";
 
@@ -56,8 +55,6 @@ export const useFeedLoader = ({
 
   const currentFeed = useZappPipesFeed(callableFeedUrl);
 
-  const cachedFeed = React.useMemo(() => path(["data"])(currentFeed), []);
-
   const riverId = screenData?.id;
 
   const reloadData = React.useCallback<ReloadDataFunction>(
@@ -92,11 +89,18 @@ export const useFeedLoader = ({
     }
   }, [callableFeedUrl, currentFeed?.data]);
 
-  // If feed doesn't exist, load it
   useEffect(() => {
-    if (!cachedFeed || pipesOptions.clearCache) {
+    if (
+      shouldDispatchData(callableFeedUrl, currentFeed, pipesOptions.clearCache)
+    ) {
       if (callableFeedUrl) {
-        dispatch(loadPipesData(callableFeedUrl, { ...pipesOptions, riverId }));
+        dispatch(
+          loadPipesData(callableFeedUrl, {
+            ...pipesOptions,
+            clearCache: true,
+            riverId,
+          })
+        );
       } else {
         logger.info({
           message:

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

@@ -17,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";

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/reactHooks/utils/index.ts

@@ -30,3 +30,16 @@ export const useIsInitialRender = (): boolean => {
 
   return isInitialRenderRef.current;
 };
+
+export const checkIsLocalFeed = (feedUrl) => feedUrl?.startsWith("pipesv2://");
+
+export const shouldDispatchData = (
+  url: string,
+  feed: ZappPipesData | null,
+  clearCache: boolean
+) => {
+  const currentFeedHasData = feed?.data;
+  const isLocalFeed = checkIsLocalFeed(url);
+
+  return !currentFeedHasData || clearCache || isLocalFeed;
+};

package/reactUtils/index.ts

@@ -152,8 +152,7 @@ export const hasTizen = typeof window?.tizen !== "undefined";
  */
 export const hasWebOS = typeof window?.webOS !== "undefined";
 
-export const getUserAgent = () =>
-  window?.navigator?.userAgent || global?.navigator?.userAgent;
+export const getUserAgent = () => window?.navigator?.userAgent;
 
 export const isLgPlatform = () => {
   const userAgent = getUserAgent();

package/services/localStorageServiceSync.web.ts

@@ -0,0 +1,48 @@
+import {
+  DEFAULT_STORAGE_NAMESPACE,
+  getWebStorageKey,
+  NAMESPACE_STORAGE_SEPARATOR_WEB,
+} from "./storageWebUtils.web";
+
+export function saveSync(
+  key: string,
+  value: string,
+  namespace: string = DEFAULT_STORAGE_NAMESPACE
+) {
+  const storageWebKey = getWebStorageKey(key, namespace);
+
+  return localStorage.setItem(storageWebKey, value);
+}
+
+export function getSync(
+  key: string,
+  namespace: string = DEFAULT_STORAGE_NAMESPACE
+) {
+  const storageWebKey = getWebStorageKey(key, namespace);
+
+  return localStorage.getItem(storageWebKey);
+}
+
+export function getAllSync(namespace: string = DEFAULT_STORAGE_NAMESPACE) {
+  const allItems = {};
+
+  for (let i = 0; i < localStorage.length; i++) {
+    const key = localStorage.key(i);
+
+    if (key && key.startsWith(namespace + NAMESPACE_STORAGE_SEPARATOR_WEB)) {
+      const itemKey = key.split(NAMESPACE_STORAGE_SEPARATOR_WEB)[1];
+      allItems[itemKey] = localStorage.getItem(key);
+    }
+  }
+
+  return allItems;
+}
+
+export function removeSync(
+  key: string,
+  namespace: string = DEFAULT_STORAGE_NAMESPACE
+) {
+  const storageWebKey = getWebStorageKey(key, namespace);
+
+  return localStorage.removeItem(storageWebKey);
+}

package/services/sessionStorageServiceSync.web.ts

@@ -0,0 +1,32 @@
+import {
+  DEFAULT_STORAGE_NAMESPACE,
+  getWebStorageKey,
+} from "./storageWebUtils.web";
+
+export function saveSync(
+  key: string,
+  value: string,
+  namespace: string = DEFAULT_STORAGE_NAMESPACE
+) {
+  const storageWebKey = getWebStorageKey(key, namespace);
+
+  return sessionStorage.setItem(storageWebKey, value);
+}
+
+export function getSync(
+  key: string,
+  namespace: string = DEFAULT_STORAGE_NAMESPACE
+) {
+  const storageWebKey = getWebStorageKey(key, namespace);
+
+  return sessionStorage.getItem(storageWebKey);
+}
+
+export function removeSync(
+  key: string,
+  namespace: string = DEFAULT_STORAGE_NAMESPACE
+) {
+  const storageWebKey = getWebStorageKey(key, namespace);
+
+  return sessionStorage.removeItem(storageWebKey);
+}

package/services/storageServiceSync.web.ts

@@ -0,0 +1,24 @@
+import { DEFAULT_STORAGE_NAMESPACE } from "./storageWebUtils.web";
+import { getSync as getLocalStorage } from "./localStorageServiceSync.web";
+import { getSync as getSessionStorage } from "./sessionStorageServiceSync.web";
+
+export const getFromSessionOrLocalStorage = (
+  key: string,
+  namespace: string = DEFAULT_STORAGE_NAMESPACE
+) => getSessionStorage(key, namespace) || getLocalStorage(key, namespace);
+
+export const resolveStorageContextKey = (storageKey: string) => {
+  if (!storageKey) {
+    return;
+  }
+
+  const splitKey = storageKey.split(".");
+  const namespaceOrKey = splitKey[0];
+  const key = splitKey[1];
+
+  if (!key) {
+    return getFromSessionOrLocalStorage(key);
+  } else {
+    return getFromSessionOrLocalStorage(key, namespaceOrKey);
+  }
+};

package/services/storageWebUtils.web.ts

@@ -0,0 +1,10 @@
+export const DEFAULT_STORAGE_NAMESPACE = "applicaster.v2";
+
+export const NAMESPACE_STORAGE_SEPARATOR_WEB = "_::_";
+
+export const getWebStorageKey = (
+  key: String,
+  namespace: String = DEFAULT_STORAGE_NAMESPACE
+) => {
+  return `${namespace}${NAMESPACE_STORAGE_SEPARATOR_WEB}${key}`;
+};

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>
   );
 };