@applicaster/zapp-react-native-utils 14.0.0-alpha.3471443312 → 14.0.0-alpha.3514550494

package/reactHooks/feed/useLoadPipesDataDispatch.ts

@@ -0,0 +1,57 @@
+import {
+  useAppDispatch,
+  ZappPipes,
+} from "@applicaster/zapp-react-native-redux";
+import { applyScreenRouteDefaults } from "@applicaster/zapp-react-native-redux/ZappPipes/feedProcessor";
+import React from "react";
+import { useScreenResolvers } from "../../actionsExecutor/screenResolver";
+import { useRoute } from "../navigation";
+import { useScreenStateStore } from "../navigation/useScreenStateStore";
+
+export const useLoadPipesDataDispatch = () => {
+  const screenStateStore = useScreenStateStore();
+  const resolvers = useScreenResolvers();
+  const dispatch = useAppDispatch();
+
+  const { pathname, screenData } = useRoute();
+
+  const riverId =
+    (screenData as LegacyNavigationScreenData)?.targetScreen?.id ??
+    screenData?.id;
+
+  const onLoadCB = (options) => (data, _err) => {
+    options?.callback?.();
+
+    if (data) {
+      applyScreenRouteDefaults(data, screenStateStore, pathname);
+    }
+  };
+
+  return React.useCallback(
+    (
+      url: string,
+      options = {},
+      {
+        withResolvers = false,
+        withScreenRouteMapping = false,
+      }: {
+        withResolvers?: boolean;
+        withScreenRouteMapping?: boolean;
+      } = {}
+    ) => {
+      if (url) {
+        dispatch(
+          ZappPipes.loadPipesData(url, {
+            riverId,
+            resolvers: withResolvers ? resolvers : undefined,
+            ...options,
+            callback: withScreenRouteMapping
+              ? onLoadCB(options)
+              : options?.callback,
+          })
+        );
+      }
+    },
+    []
+  );
+};

package/reactHooks/flatList/useSequentialRenderItem.tsx

@@ -1,6 +1,6 @@
 import * as React from "react";
 import * as R from "ramda";
-import { View } from "react-native";
+import { View, ViewStyle } from "react-native";
 
 import { platformSelect } from "../../reactUtils";
 
@@ -49,13 +49,13 @@ export const useSequentialRenderItem = (data: Data) => {
         const readyToDisplay =
           index === 0 ? true : arePreviousComponentsReady(index);
 
-        const displayStyle = {
+        const displayStyle: ViewStyle = {
           display: readyToDisplay ? "flex" : "none",
         };
 
         const readyStyle = {
           visibility: readyToDisplay ? "visible" : "hidden",
-        };
+        } as ViewStyle;
 
         const style = platformSelect({
           tvos: readyStyle,

package/reactHooks/layout/isTablet/index.ts

@@ -1,5 +1,11 @@
 import { NativeModules, Platform } from "react-native";
 
+export const isAndroidTablet = () => {
+  const { initialProps } = NativeModules.QuickBrickCommunicationModule;
+
+  return initialProps?.is_tablet;
+};
+
 /**
  * Determines wether the given device is a tablet based on dimensions, orientation, and platform
  * @param {Object} dimensions - Dimensions object passed to the function
@@ -13,9 +19,7 @@ export const isTablet = (
   if (Platform?.OS === "ios") {
     return Platform?.isPad;
   } else if (Platform?.OS === "android") {
-    const { initialProps } = NativeModules.QuickBrickCommunicationModule;
-
-    return initialProps?.is_tablet;
+    return isAndroidTablet();
   }
 
   const { width } = dimensions || {};

package/reactHooks/navigation/index.ts

@@ -14,7 +14,7 @@ import { HOOKS_EVENTS } from "../../appUtils/HooksManager/constants";
 import { getRiverFromRoute, getTargetRoute } from "../../navigationUtils";
 import { useConnectionInfo } from "../connection";
 
-import { isTV } from "@applicaster/zapp-react-native-utils/reactUtils";
+import { isTV, isWeb } from "@applicaster/zapp-react-native-utils/reactUtils";
 import { useNavbarState } from "../screen";
 
 export { useNavigation } from "./useNavigation";
@@ -127,11 +127,13 @@ export function isNavBarVisible(
 
 export const useBackHandler = (cb: () => boolean) => {
   useEffect(() => {
-    BackHandler.addEventListener("hardwareBackPress", cb);
+    if (!isWeb()) {
+      const unsubscribe = BackHandler.addEventListener("hardwareBackPress", cb);
 
-    return () => {
-      BackHandler.removeEventListener("hardwareBackPress", cb);
-    };
+      return () => {
+        unsubscribe.remove();
+      };
+    }
   }, [cb]);
 };
 

package/reactHooks/navigation/useRoute.ts

@@ -28,14 +28,19 @@ const isHookPathname = (pathname: string) => /^\/hooks\//.test(pathname);
 
 type VariousScreenData = LegacyNavigationScreenData | ZappRiver | ZappEntry;
 
-export const useRoute = (): {
+export const useRoute = (
+  useLegacy = true
+): {
   screenData: VariousScreenData;
   pathname: string;
 } => {
   const pathname = usePathname() || "";
   const navigator = useNavigation();
+  const screenContext = useContext(ScreenDataContext);
 
-  const screenDataContext = legacyScreenData(useContext(ScreenDataContext));
+  const screenDataContext = useLegacy
+    ? legacyScreenData(screenContext)
+    : screenContext;
 
   const { plugins, contentTypes, rivers } = usePickFromState([
     "plugins",

package/reactHooks/navigation/useScreenStateStore.ts

@@ -0,0 +1,8 @@
+import { useScreenContextV2 } from "../screen/useScreenContext";
+import { useMemo } from "react";
+
+export const useScreenStateStore = () => {
+  const _stateStore = useScreenContextV2()._stateStore;
+
+  return useMemo(() => _stateStore, []);
+};

package/reactHooks/state/index.ts

@@ -1,5 +1,5 @@
 export { useRivers } from "./useRivers";
 
-export { useHomeRiver } from "./useHomeRiver";
+export { useHomeRiver, getHomeRiver } from "./useHomeRiver";
 
 export { ZStoreProvider, useZStore } from "./ZStoreProvider";

package/reactHooks/state/useHomeRiver.ts

@@ -1,8 +1,10 @@
-import * as R from "ramda";
 import { useRivers } from "./useRivers";
 
+export const getHomeRiver = (rivers: Record<string, ZappRiver>) =>
+  Object.values(rivers).find((river: ZappRiver) => river.home);
+
 export const useHomeRiver = () => {
   const rivers = useRivers();
 
-  return R.compose(R.find(R.propEq("home", true)), R.values)(rivers);
+  return getHomeRiver(rivers);
 };

package/screenPickerUtils/index.ts

@@ -0,0 +1,7 @@
+export const getFocusableId = (id) => `PickerItem.${id}`;
+
+export const getPickerSelectorId = (id) => `PickerSelector.${id}`;
+
+export const SCREEN_PICKER_CONTAINER = "ScreenPickerContainer";
+
+export const getScreenPickerId = (id) => `${SCREEN_PICKER_CONTAINER}.${id}`;

package/storage/ScreenSingleValueProvider.ts

@@ -0,0 +1,204 @@
+import { BehaviorSubject } from "rxjs";
+import { SingleValueProvider } from "./StorageSingleSelectProvider";
+import { createLogger } from "../logger";
+import { bridgeLogger } from "../../zapp-react-native-bridge/logger";
+import { useScreenStateStore } from "../reactHooks/navigation/useScreenStateStore";
+
+export const { log_debug, log_error } = createLogger({
+  category: "ScreenSingleValueProvider",
+  subsystem: "zapp-react-native-bridge",
+  parent: bridgeLogger,
+});
+
+export class ScreenSingleValueProvider implements SingleValueProvider {
+  // @ts-ignore
+  private valueSubject: BehaviorSubject<string | null>;
+  private screenStateStoreUnsubscribe: (() => void) | null = null;
+
+  private static providers: Record<
+    string,
+    Record<string, SingleValueProvider>
+  > = {};
+
+  public static getProvider(
+    key: string,
+    screenRoute: string,
+    screenStateStore: ReturnType<typeof useScreenStateStore>
+  ): SingleValueProvider {
+    if (!key) {
+      throw new Error("ScreenSingleValueProvider: Key is required");
+    }
+
+    if (!screenRoute) {
+      throw new Error("ScreenSingleValueProvider: Screen route is required");
+    }
+
+    if (!screenStateStore) {
+      throw new Error(
+        "ScreenSingleValueProvider: screen state store is required"
+      );
+    }
+
+    if (!this.providers[screenRoute]) {
+      this.providers[screenRoute] = {};
+    }
+
+    try {
+      if (!this.providers[screenRoute][key]) {
+        this.providers[screenRoute][key] = new ScreenSingleValueProvider(
+          key,
+          screenRoute,
+          screenStateStore
+        );
+      } else {
+        (
+          this.providers[screenRoute][key] as ScreenSingleValueProvider
+        ).updateStore(screenStateStore);
+      }
+    } catch (error) {
+      log_error("Failed to create provider", { key, screenRoute, error });
+      throw error;
+    }
+
+    return this.providers[screenRoute][key];
+  }
+
+  // @ts-ignore
+  private constructor(
+    private key: string,
+    route: string,
+    private screenStateStore: ReturnType<typeof useScreenStateStore>
+  ) {
+    if (!key) {
+      throw new Error("ScreenSingleValueProvider: Key is required");
+    }
+
+    if (!screenStateStore) {
+      throw new Error(
+        "ScreenSingleValueProvider: screen state store is required"
+      );
+    }
+
+    this.key = key;
+    this.valueSubject = new BehaviorSubject<string | null>(null);
+
+    this.setupScreenStateSubscription();
+
+    void this.getValueAsync();
+
+    log_debug("ScreenSingleValueProvider: Initializing", { key, route });
+  }
+
+  private updateStore(
+    screenStateStore: ReturnType<typeof useScreenStateStore>
+  ): void {
+    this.cleanup();
+    this.screenStateStore = screenStateStore;
+    this.setupScreenStateSubscription();
+    void this.getValueAsync();
+  }
+
+  private setupScreenStateSubscription(): void {
+    this.screenStateStoreUnsubscribe = this.screenStateStore.subscribe(
+      (state) => ({
+        value: state.data[this.key],
+        exists: this.key in state.data,
+      })
+      // (current, previous) => {
+      //   if (!current.exists && previous.exists) {
+      //     log_debug(
+      //       `ScreenSingleValueProvider: Key deleted from store: ${this.key}`
+      //     );
+
+      //     // TODO: If we need to handle deletion, we can do it here
+      //   }
+
+      //   if (current.value !== previous.value) {
+      //     this.valueSubject.next(current.value || null);
+
+      //     log_debug(`ScreenSingleValueProvider: Key updated: ${this.key}`, {
+      //       previous: previous.value,
+      //       current: current.value,
+      //     });
+      //   }
+      // }
+    );
+
+    log_debug(
+      `ScreenSingleValueProvider: screen state store subscription setup for key: ${this.key}`
+    );
+  }
+
+  private cleanup(): void {
+    if (this.screenStateStoreUnsubscribe) {
+      this.screenStateStoreUnsubscribe();
+      this.screenStateStoreUnsubscribe = null;
+
+      log_debug(
+        `ScreenSingleValueProvider: Unsubscribed from screen state store for key: ${this.key}`
+      );
+    }
+  }
+
+  clearValue(): Promise<void> {
+    this.screenStateStore.getState().removeValue(this.key);
+    this.valueSubject.next(null);
+
+    log_debug(`clearValue: value cleared for key: ${this.key}`);
+
+    return Promise.resolve();
+  }
+
+  getObservable(): BehaviorSubject<string | null> {
+    return this.valueSubject;
+  }
+
+  getValue(): string | null {
+    return this.valueSubject.value;
+  }
+
+  getValueAsync(): Promise<string | null> {
+    const currentValue = this.screenStateStore.getState().data[this.key];
+    const value = currentValue || null;
+    const selected = this.getValue();
+    const valuesAreEqual = value === selected;
+
+    const bothEmpty =
+      (value === null || value === "") &&
+      (selected === null || selected === "");
+
+    if (!this.valueSubject.closed && !valuesAreEqual && !bothEmpty) {
+      this.valueSubject.next(value);
+    }
+
+    return Promise.resolve(value);
+  }
+
+  setValue(value: string): Promise<void> {
+    this.screenStateStore.getState().setValue(this.key, value);
+    this.valueSubject.next(value);
+
+    log_debug(`setValue: value set for key: ${this.key}`, { value });
+
+    return Promise.resolve();
+  }
+
+  // TODO: remove if not needed
+
+  public static cleanupRoute(screenRoute: string): void {
+    if (this.providers[screenRoute]) {
+      Object.values(this.providers[screenRoute]).forEach((provider) => {
+        (provider as ScreenSingleValueProvider).destroy();
+      });
+
+      delete this.providers[screenRoute];
+    }
+  }
+
+  // TODO: remove if not needed
+
+  public destroy(): void {
+    this.valueSubject.complete();
+    this.cleanup();
+  }
+}

package/storage/ScreenStateMultiSelectProvider.ts

@@ -0,0 +1,293 @@
+import { MultiSelectProvider } from "./StorageMultiSelectProvider";
+import { BehaviorSubject } from "rxjs";
+import { createLogger } from "../logger";
+import { bridgeLogger } from "../../zapp-react-native-bridge/logger";
+import { useScreenStateStore } from "../reactHooks/navigation/useScreenStateStore";
+
+export const { log_debug, log_error } = createLogger({
+  category: "ScreenMultiSelectProvider",
+  subsystem: "zapp-react-native-bridge",
+  parent: bridgeLogger,
+});
+
+export class ScreenMultiSelectProvider implements MultiSelectProvider {
+  // @ts-ignore
+  private itemSubject: BehaviorSubject<string[] | null>;
+  private screenStateStoreUnsubscribe: (() => void) | null = null;
+
+  private static providers: Record<
+    string,
+    Record<string, MultiSelectProvider>
+  > = {};
+
+  public static getProvider(
+    key: string,
+    screenRoute: string,
+    screenStateStore: ReturnType<typeof useScreenStateStore>
+  ): MultiSelectProvider {
+    if (!key) {
+      throw new Error("ScreenMultiSelectProvider: Key is required");
+    }
+
+    if (!screenRoute) {
+      throw new Error("ScreenMultiSelectProvider: Screen route is required");
+    }
+
+    if (!screenStateStore) {
+      throw new Error(
+        "ScreenMultiSelectProvider: screen state store is required"
+      );
+    }
+
+    if (!this.providers[screenRoute]) {
+      this.providers[screenRoute] = {};
+    }
+
+    try {
+      if (!this.providers[screenRoute][key]) {
+        this.providers[screenRoute][key] = new ScreenMultiSelectProvider(
+          key,
+          screenRoute,
+          screenStateStore
+        );
+      } else {
+        (
+          this.providers[screenRoute][key] as ScreenMultiSelectProvider
+        ).updateStore(screenStateStore);
+      }
+    } catch (error) {
+      log_error("Failed to create provider", { key, screenRoute, error });
+      throw error;
+    }
+
+    return this.providers[screenRoute][key];
+  }
+
+  // @ts-ignore
+  private constructor(
+    private key: string,
+    route: string,
+    private screenStateStore: ReturnType<typeof useScreenStateStore>
+  ) {
+    if (!key) {
+      throw new Error("ScreenMultiSelectProvider: Key is required");
+    }
+
+    if (!screenStateStore) {
+      throw new Error(
+        "ScreenMultiSelectProvider: screen state store is required"
+      );
+    }
+
+    this.key = key;
+    this.itemSubject = new BehaviorSubject<string[]>([]);
+
+    this.setupScreenStateSubscription();
+
+    void this.getSelectedAsync();
+
+    log_debug("ScreenMultiSelectProvider: Initializing", { key, route });
+  }
+
+  private updateStore(
+    screenStateStore: ReturnType<typeof useScreenStateStore>
+  ): void {
+    if (screenStateStore === this.screenStateStore) {
+      return;
+    }
+
+    this.cleanup();
+    this.screenStateStore = screenStateStore;
+    this.setupScreenStateSubscription();
+    void this.getSelectedAsync();
+  }
+
+  private setupScreenStateSubscription(): void {
+    this.screenStateStoreUnsubscribe = this.screenStateStore.subscribe(
+      (state) => ({
+        value: state.data[this.key],
+        exists: this.key in state.data,
+      })
+      // (current, previous) => {
+      //   if (!current.exists && previous.exists) {
+      //     log_debug(
+      //       `ScreenMultiSelectProvider: Key deleted from store: ${this.key}`
+      //     );
+
+      //     // TODO: If we need to handle deletion, we can do it here
+      //   }
+
+      //   if (current.value !== previous.value) {
+      //     const items = this.parseStoredValue(current.value);
+      //     this.itemSubject.next(items);
+
+      //     log_debug(`ScreenMultiSelectProvider: Key updated: ${this.key}`, {
+      //       previous: this.parseStoredValue(previous.value),
+      //       current: items,
+      //     });
+      //   }
+      // }
+    );
+
+    log_debug(
+      `ScreenMultiSelectProvider: screen state store subscription setup for key: ${this.key}`
+    );
+  }
+
+  private parseStoredValue(value: string): string[] {
+    if (!value) return [];
+
+    return typeof value === "string"
+      ? value.split(",").filter((item) => item.length > 0)
+      : [];
+  }
+
+  private formatValueForStorage(items: string[]): string {
+    return items.join(",");
+  }
+
+  private getCurrentItems(): Set<string> {
+    const currentValue = this.screenStateStore.getState().data[this.key];
+    const items = this.parseStoredValue(currentValue);
+
+    return new Set(items);
+  }
+
+  private updateScreenState(items: Set<string>): void {
+    const itemsArray = Array.from(items);
+    const formattedValue = this.formatValueForStorage(itemsArray);
+
+    this.screenStateStore.getState().setValue(this.key, formattedValue);
+    const itemsToUpdate = Array.from(items) || [];
+    this.itemSubject.next(itemsToUpdate);
+  }
+
+  private cleanup(): void {
+    if (this.screenStateStoreUnsubscribe) {
+      this.screenStateStoreUnsubscribe();
+      this.screenStateStoreUnsubscribe = null;
+
+      log_debug(
+        `ScreenMultiSelectProvider: Unsubscribed from screen state store for key: ${this.key}`
+      );
+    }
+  }
+
+  addItem(item: string): Promise<void> {
+    const items = this.getCurrentItems();
+    items.add(item);
+    this.updateScreenState(items);
+
+    log_debug(
+      `addItem: item added: ${item}, current items: [${Array.from(items).join(", ")}]`
+    );
+
+    return Promise.resolve();
+  }
+
+  addItems(itemsToAdd: string[]): Promise<void> {
+    const items = this.getCurrentItems();
+
+    for (const item of itemsToAdd) {
+      items.add(item);
+    }
+
+    this.updateScreenState(items);
+
+    log_debug(
+      `addItems: items added: [${itemsToAdd.join(", ")}], current items: [${Array.from(items).join(", ")}]`
+    );
+
+    return Promise.resolve();
+  }
+
+  public getObservable = (): BehaviorSubject<string[]> => this.itemSubject;
+
+  getSelectedAsync(): Promise<string[]> {
+    const currentValue = this.screenStateStore.getState().data[this.key] || [];
+    const values = this.parseStoredValue(currentValue);
+    const selected = this.getSelectedItems();
+
+    const arraysAreEqual =
+      Array.isArray(values) &&
+      Array.isArray(selected) &&
+      values.length === selected.length &&
+      values.every((val, index) => val === selected[index]);
+
+    const bothEmpty = values.length === 0 && selected.length === 0;
+
+    if (!this.itemSubject.closed && !arraysAreEqual && !bothEmpty) {
+      this.itemSubject.next(values);
+    }
+
+    return Promise.resolve(values);
+  }
+
+  getSelectedItems(): string[] {
+    return this.itemSubject.value || [];
+  }
+
+  removeAllItems(): Promise<void> {
+    this.screenStateStore.getState().removeValue(this.key);
+    this.itemSubject.next([]);
+
+    log_debug(`removeAllItems: all items removed for key: ${this.key}`);
+
+    return Promise.resolve();
+  }
+
+  removeItem(item: string): Promise<void> {
+    const items = this.getCurrentItems();
+    items.delete(item);
+
+    this.updateScreenState(items);
+
+    log_debug(
+      `removeItem: item removed: ${item}, remaining items: ${Array.from(items).join(", ")}`
+    );
+
+    return Promise.resolve();
+  }
+
+  removeItems(itemsToRemove: string[]): Promise<void> {
+    const items = this.getCurrentItems();
+
+    for (const item of itemsToRemove) {
+      items.delete(item);
+    }
+
+    this.updateScreenState(items);
+
+    log_debug(
+      `removeItems: items removed: [${itemsToRemove.join(", ")}], remaining items: [${Array.from(items).join(", ")}]`
+    );
+
+    return Promise.resolve();
+  }
+
+  setSelectedItems(items: string[]): Promise<void> {
+    this.updateScreenState(new Set(items));
+    log_debug(`setSelectedItems: items set to: [${items.join(", ")}]`);
+
+    return Promise.resolve();
+  }
+
+  // TODO: remove if not needed
+
+  public static cleanupRoute(screenRoute: string): void {
+    if (this.providers[screenRoute]) {
+      Object.values(this.providers[screenRoute]).forEach((provider) => {
+        (provider as ScreenMultiSelectProvider).destroy();
+      });
+
+      delete this.providers[screenRoute];
+    }
+  }
+
+  // TODO: remove if not needed
+
+  public destroy(): void {
+    this.itemSubject.complete();
+    this.cleanup();
+  }
+}