@applicaster/zapp-react-native-utils 13.0.0-alpha.1753452014 → 13.0.0-alpha.1756731121

package/reactHooks/navigation/useRoute.ts

@@ -7,12 +7,11 @@ import { usePickFromState } from "@applicaster/zapp-react-native-redux/hooks";
 
 import { legacyScreenData } from "@applicaster/quick-brick-core/App/NavigationProvider/utils";
 
-import { useZappHooksModalState } from "@applicaster/zapp-react-dom-ui-components/Components/ZappHooksModal/hooks/useZappHooksModalState";
-
 import { getTargetScreenData } from "../screen/useTargetScreenData";
+import { useHookModalScreenData } from "../hookModal/hooks/useHookModalScreenData";
 
 import { useNavigation } from "./useNavigation";
-import { useModalStore } from "../../modalState";
+import { useModalStoreState } from "../../modalState";
 import { ScreenDataContext } from "@applicaster/zapp-react-native-ui-components/Contexts/ScreenDataContext";
 import { usePathname } from "./usePathname";
 
@@ -44,12 +43,11 @@ export const useRoute = (): {
     "contentTypes",
   ]);
 
-  const { modalState } = useModalStore();
-  const hookModalState = useZappHooksModalState();
+  const modalState = useModalStoreState();
 
   const modalScreenData = modalState.screen;
 
-  const hookModalScreenData = hookModalState.state.screenData?.payload;
+  const hookModalScreenData = useHookModalScreenData();
 
   const videoModalScreenData =
     navigator?.videoModalState?.item &&

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

@@ -0,0 +1,69 @@
+import { renderHook } from "@testing-library/react-hooks";
+
+jest.mock(
+  "@applicaster/zapp-react-native-ui-components/Components/River/useScreenConfiguration",
+  () => ({
+    useScreenConfiguration: jest.fn(),
+  })
+);
+
+const {
+  useScreenConfiguration,
+} = require("@applicaster/zapp-react-native-ui-components/Components/River/useScreenConfiguration");
+
+const { useScreenBackgroundColor } = require("../useScreenBackgroundColor");
+
+describe("useScreenBackgroundColor", () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should return the background color from screen configuration", () => {
+    useScreenConfiguration.mockReturnValue({
+      backgroundColor: "#FF0000",
+    });
+
+    // Render the hook with a screen ID
+    const { result } = renderHook(() =>
+      useScreenBackgroundColor("test-screen-id")
+    );
+
+    expect(result.current).toBe("#FF0000");
+
+    expect(useScreenConfiguration).toHaveBeenCalledWith("test-screen-id");
+  });
+
+  it("should return 'transparent' when background color is empty", () => {
+    useScreenConfiguration.mockReturnValue({
+      backgroundColor: "",
+    });
+
+    const { result } = renderHook(() =>
+      useScreenBackgroundColor("test-screen-id")
+    );
+
+    expect(result.current).toBe("transparent");
+  });
+
+  it("should return 'transparent' when background color is null", () => {
+    useScreenConfiguration.mockReturnValue({
+      backgroundColor: null,
+    });
+
+    const { result } = renderHook(() =>
+      useScreenBackgroundColor("test-screen-id")
+    );
+
+    expect(result.current).toBe("transparent");
+  });
+
+  it("should return 'transparent' when background color is undefined", () => {
+    useScreenConfiguration.mockReturnValue({});
+
+    const { result } = renderHook(() =>
+      useScreenBackgroundColor("test-screen-id")
+    );
+
+    expect(result.current).toBe("transparent");
+  });
+});

package/reactHooks/screen/useScreenBackgroundColor.ts

@@ -1,23 +1,11 @@
-import * as React from "react";
-import { useTheme } from "@applicaster/zapp-react-native-utils/theme";
 import { useScreenConfiguration } from "@applicaster/zapp-react-native-ui-components/Components/River/useScreenConfiguration";
 import { ifEmptyUseFallback } from "@applicaster/zapp-react-native-utils/cellUtils";
 
+const DEFAULT_BACKGROUND_FALLBACK = "transparent";
+
 export const useScreenBackgroundColor = (screenId: string): string => {
   const { backgroundColor: screenBackgroundColor } =
     useScreenConfiguration(screenId);
 
-  const theme = useTheme();
-
-  const themeBackgroundColor = React.useMemo(
-    () => theme.app_background_color,
-    [theme.app_background_color]
-  );
-
-  const backgroundColor = ifEmptyUseFallback(
-    screenBackgroundColor,
-    themeBackgroundColor
-  );
-
-  return backgroundColor;
+  return ifEmptyUseFallback(screenBackgroundColor, DEFAULT_BACKGROUND_FALLBACK);
 };

package/reactHooks/useListenEventBusEvent.ts

@@ -23,5 +23,5 @@ export const useListenEventBusEvent = (
         sub.remove(); // stop listening to DeviceEventEmitter
       };
     }
-  }, []);
+  }, [handler, subscriptionID, source, events]);
 };

package/reactUtils/index.ts

@@ -187,3 +187,12 @@ export const hasVizioAPIs = () => {
 
   return hasAPIs;
 };
+
+/**
+ * Checks if the Android version is at least the expected version
+ * @param expectedVersion The version to compare against
+ * @returns True if the current Android version is at least the expected version, false otherwise
+ */
+export const isAndroidVersionAtLeast = (expectedVersion: number) => {
+  return parseFloat(Platform.Version.toString()) >= expectedVersion;
+};

package/time/BackgroundTimer.ts

@@ -0,0 +1,55 @@
+import { DeviceEventEmitter, NativeModules } from "react-native";
+import { platformSelect } from "../reactUtils";
+
+const { BackgroundTimer: RNBackgroundTimer } = NativeModules;
+
+class BackgroundTimer {
+  private uniqueId: number;
+  private readonly callbacks: Record<number, () => void>;
+
+  constructor() {
+    this.uniqueId = 0;
+    this.callbacks = {};
+
+    const EventEmitter = platformSelect({
+      android: DeviceEventEmitter,
+      ios: undefined,
+      default: undefined,
+    });
+
+    EventEmitter?.addListener("BackgroundTimer.timer.fired", (id: number) => {
+      if (this.callbacks[id]) {
+        const callback = this.callbacks[id];
+        delete this.callbacks[id];
+        callback();
+      }
+    });
+  }
+
+  setTimeout(callback, timeout): number | NodeJS.Timeout {
+    if (!RNBackgroundTimer) {
+      return global.setTimeout(callback, timeout);
+    }
+
+    this.uniqueId += 1;
+    const timeoutId = this.uniqueId;
+
+    this.callbacks[timeoutId] = callback;
+    RNBackgroundTimer.setTimeout(timeoutId, timeout);
+
+    return timeoutId;
+  }
+
+  clearTimeout(timeoutId: number | NodeJS.Timeout): void {
+    if (!RNBackgroundTimer) {
+      return global.clearTimeout(timeoutId as NodeJS.Timeout);
+    }
+
+    if (this.callbacks[timeoutId as number]) {
+      delete this.callbacks[timeoutId as number];
+      RNBackgroundTimer.clearTimeout(timeoutId);
+    }
+  }
+}
+
+export default new BackgroundTimer();

package/time/Timer.ts

@@ -1,19 +1,19 @@
+import BackgroundTimer from "./BackgroundTimer";
+
 export class Timer {
   private startTime: number;
-  private remaining: number;
-  private timeoutId: NodeJS.Timeout | null;
+  private timeoutId: number | NodeJS.Timeout | null;
 
   constructor(
     private callback: () => void,
-    private duration: number
+    private remaining: number = null
   ) {
-    this.remaining = this.duration;
     this.timeoutId = null;
   }
 
   start(): void {
     this.startTime = Date.now();
-    this.timeoutId = setTimeout(this.callback, this.remaining);
+    this.timeoutId = BackgroundTimer.setTimeout(this.callback, this.remaining);
 
     this.remaining = 0;
   }
@@ -29,6 +29,6 @@ export class Timer {
   }
 
   clear(): void {
-    clearTimeout(this.timeoutId);
+    BackgroundTimer.clearTimeout(this.timeoutId);
   }
 }

package/utils/README.md

@@ -0,0 +1,30 @@
+### ramda replacement utils
+
+See contribution guide below
+
+## Reference
+
+Prefer non-fp variant as it more performant - if refactoring assumes you need more efforts rewrite ramda sample to lodash and it can be easily replaced with lodash-fp - use lodash-fp.
+
+### Ramda alternatives:
+
+Custom
+- `splitEvery` => `chunk`
+- `times` => `times`
+
+From `lodash`
+- `clone` => `clone`
+- `flatten` => `flatten`
+- `drop` => `drop`
+- `length` => `size`
+
+
+## Contribution
+
+To add new helper function as ramda replacement
+
+1. Search for replacement ( you can use lodash or pure JS solution), arguments should match with Ramda definition (for easier transition).
+2. Add new file if needed, add test, update exports in index file. 2.1. Make sure it's well-typed.
+3. If the function can-be reexported from other 3rd party lib - update index.ts to re-export it.
+4. Make sure README is updated and contains reference for newly added function.
+5. You can use AI's help. Use query like 'lodash & lodash/fp equivalent of Ramda's R.clone function' to get an options you can use.

package/utils/chunk.ts

@@ -0,0 +1,5 @@
+import { chunk as _chunk } from "lodash";
+
+export const chunk = <T>(size: number, array: T[]): T[][] => {
+  return _chunk(array, size);
+};

package/utils/index.ts

@@ -0,0 +1,5 @@
+export { chunk } from "./chunk";
+
+export { times } from "./times";
+
+export { cloneDeep as clone, flatten, drop, size, isNil } from "lodash";

package/utils/times.ts

@@ -0,0 +1,5 @@
+import { times as _times } from "lodash";
+
+export const times = <T>(iteratee: (index: number) => T, n: number) => {
+  return _times(n, iteratee);
+};

package/zappFrameworkUtils/localStorageHelper.ts

@@ -1,6 +1,12 @@
 import { localStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/LocalStorage";
 import { isNilOrEmpty } from "../reactUtils/helpers";
 import { parseJsonIfNeeded } from "@applicaster/zapp-react-native-utils/functionUtils";
+import {
+  StorageOwnedValues,
+  NamespaceValues,
+  StorageValuesToRemove,
+  StorageValuesToAdd,
+} from "./types";
 
 const defaultOwnedKey = "owned_keys";
 const DEFAULT_NAMESPACE = "applicaster.v2";

package/zappFrameworkUtils/loginPluginUtils.ts

@@ -89,11 +89,15 @@ const runInBackground = async ({
     const shouldPresent = await hookPresentPolicy.shouldPresentScreen();
 
     if (!shouldPresent) {
+      const isRefreshed = await checkUserAuthenticated();
+
       log_info(
-        "runInBackground: Background mode finished, hook plugin will be skipped"
+        `runInBackground: Background mode finished, ${isRefreshed ? "finish hook with completion true" : "refresh failed will presentUI"}`
       );
 
-      await checkUserAuthenticated();
+      isRefreshed
+        ? callback({ success: isRefreshed, payload: item })
+        : presentUI();
 
       return;
     }

package/zappFrameworkUtils/types.ts

@@ -0,0 +1,11 @@
+export type StorageValuesToAdd = Record<string, NamespaceValues>;
+
+export type StorageValuesToRemove = {
+  string?: string[];
+};
+
+export type StorageOwnedValues = {
+  string?: string[];
+};
+
+export type NamespaceValues = Record<string, string>;