@applicaster/zapp-react-native-utils 13.0.0-rc.99 → 14.0.0-alpha.1235043154

package/reactHooks/state/ZStoreProvider.tsx

@@ -0,0 +1,71 @@
+import React, { createContext, useContext, ReactNode, useMemo } from "react";
+import { create, UseBoundStore } from "zustand";
+
+interface ZStoreContextType {
+  stores: Map<string, UseBoundStore<any>>;
+  registerStore: (name: string, store: UseBoundStore<any>) => void;
+  getStore: (name: string) => UseBoundStore<any> | undefined;
+}
+
+const ZStoreContext = createContext<ZStoreContextType | null>(null);
+
+interface ZStoreProviderProps {
+  children: ReactNode;
+  name: string;
+  value: any;
+}
+
+export const ZStoreProvider: React.FC<ZStoreProviderProps> = ({
+  children,
+  name,
+  value,
+}) => {
+  const parentContext = useContext(ZStoreContext);
+
+  const context = useMemo(() => {
+    if (parentContext) {
+      // If parent context exists, create a new store and register it
+      const store = create(() => value);
+      parentContext.registerStore(name, store);
+
+      return parentContext;
+    }
+
+    // Create a new context if none exists
+    const stores = new Map<string, UseBoundStore<any>>();
+
+    // Create a store from the provided value
+    const store = create(() => value);
+    stores.set(name, store);
+
+    return {
+      stores,
+      registerStore: (storeName: string, storeInstance: UseBoundStore<any>) => {
+        stores.set(storeName, storeInstance);
+      },
+      getStore: (storeName: string) => stores.get(storeName),
+    };
+  }, [parentContext, name, value]);
+
+  return (
+    <ZStoreContext.Provider value={context}>{children}</ZStoreContext.Provider>
+  );
+};
+
+export const useZStore = (name: string): UseBoundStore<any> => {
+  const context = useContext(ZStoreContext);
+
+  if (!context) {
+    throw new Error("useZStore must be used within a ZStoreProvider");
+  }
+
+  const store = context.getStore(name);
+
+  if (!store) {
+    throw new Error(
+      `Store with name "${name}" not found. Make sure it's provided by a ZStoreProvider.`
+    );
+  }
+
+  return store;
+};

package/reactHooks/state/__tests__/ZStoreProvider.test.tsx

@@ -0,0 +1,66 @@
+import React from "react";
+import { render, screen } from "@testing-library/react-native";
+import { Text } from "react-native";
+import { ZStoreProvider, useZStore } from "../ZStoreProvider";
+import { useStore } from "zustand";
+
+interface TestState {
+  value: string;
+}
+
+// Test component that uses the store
+const TestComponent = ({ storeName }: { storeName: string }) => {
+  const store = useZStore(storeName);
+  const value = useStore(store, (state: any) => (state as TestState).value);
+
+  return <Text testID="test-value">{value}</Text>;
+};
+
+// Test component that provides a store
+const TestProvider = ({ children }: { children: React.ReactNode }) => {
+  return (
+    <ZStoreProvider name="testStore" value={{ value: "test-value" }}>
+      {children}
+    </ZStoreProvider>
+  );
+};
+
+describe("ZStoreProvider and useZStore", () => {
+  it("should provide a store and allow access via useZStore", () => {
+    render(
+      <TestProvider>
+        <TestComponent storeName="testStore" />
+      </TestProvider>
+    );
+
+    expect(screen.getByTestId("test-value").props.children).toBe("test-value");
+  });
+
+  it("should throw error when useZStore is used outside provider", () => {
+    // Suppress console.error for this test
+    const originalError = console.error;
+    console.error = jest.fn();
+
+    expect(() => {
+      render(<TestComponent storeName="testStore" />);
+    }).toThrow("useZStore must be used within a ZStoreProvider");
+
+    console.error = originalError;
+  });
+
+  it("should throw error when store name is not found", () => {
+    // Suppress console.error for this test
+    const originalError = console.error;
+    console.error = jest.fn();
+
+    expect(() => {
+      render(
+        <TestProvider>
+          <TestComponent storeName="nonExistentStore" />
+        </TestProvider>
+      );
+    }).toThrow('Store with name "nonExistentStore" not found');
+
+    console.error = originalError;
+  });
+});

package/reactHooks/state/index.ts

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

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/testUtils/index.tsx

@@ -1,17 +1,16 @@
-import * as R from "ramda";
-
+import { SafeAreaProvider } from "react-native-safe-area-context";
+import { render } from "@testing-library/react-native";
 import React, { PropsWithChildren } from "react";
-import { View } from "react-native";
-
+import configureStore from "redux-mock-store";
 import { Provider } from "react-redux";
+import { View } from "react-native";
 import thunk from "redux-thunk";
-import configureStore from "redux-mock-store";
-import { SafeAreaProvider } from "react-native-safe-area-context";
+import * as R from "ramda";
+
 import { appStore } from "@applicaster/zapp-react-native-redux/AppStore";
 
-import { render } from "@testing-library/react-native";
-import { AnalyticsProvider } from "../analyticsUtils";
 import { ThemeContext } from "../theme";
+import { AnalyticsProvider } from "../analyticsUtils";
 
 export { getByTestId } from "./getByTestId";
 

package/typeGuards/index.ts

@@ -0,0 +1,3 @@
+export const isString = (value: unknown) => {
+  return typeof value === "string";
+};

package/utils/index.ts

@@ -2,4 +2,15 @@ export { chunk } from "./chunk";
 
 export { times } from "./times";
 
-export { cloneDeep as clone, flatten, drop, size } from "lodash";
+export {
+  cloneDeep as clone,
+  flatten,
+  drop,
+  size,
+  isNil,
+  isEmpty,
+  get,
+  has,
+  flatMap,
+  difference,
+} from "lodash";

package/zappFrameworkUtils/localStorageHelper.ts

@@ -7,6 +7,7 @@ import {
   StorageValuesToRemove,
   StorageValuesToAdd,
 } from "./types";
+import { Storage } from "@applicaster/zapp-react-native-bridge/ZappStorage/Storage";
 
 const defaultOwnedKey = "owned_keys";
 const DEFAULT_NAMESPACE = "applicaster.v2";
@@ -50,8 +51,9 @@ function mapOwnedKeysToAdd(
   return mappedData;
 }
 
-export async function batchSaveToLocalStorage(
-  storageValues: StorageValuesToAdd
+export async function batchSave(
+  storageValues: StorageValuesToAdd,
+  storage: Storage
 ) {
   if (isNilOrEmpty(storageValues)) {
     return false;
@@ -64,24 +66,37 @@ export async function batchSaveToLocalStorage(
       const value = namespaceData[key];
 
       if (!isNilOrEmpty(value)) {
-        await localStorage.setItem(key, value, namespace);
+        await storage.setItem(key, value, namespace);
       }
     }
   }
 }
 
-export async function batchRemoveFromLocalStorage(
-  storageValues: StorageValuesToRemove
+export async function batchSaveToLocalStorage(
+  storageValues: StorageValuesToAdd
+) {
+  return await batchSave(storageValues, localStorage);
+}
+
+export async function batchRemoveFromStorage(
+  storageValues: StorageValuesToRemove,
+  storage: Storage = localStorage
 ) {
   for (const namespace of Object.keys(storageValues)) {
     const namespaceData = storageValues[namespace];
 
     for (const key of namespaceData) {
-      await localStorage.removeItem(key, namespace);
+      await storage.removeItem(key, namespace);
     }
   }
 }
 
+export async function batchRemoveFromLocalStorage(
+  storageValues: StorageValuesToRemove
+) {
+  await batchRemoveFromStorage(storageValues, localStorage);
+}
+
 async function addOwnedKeys({
   newKeys,
   ownershipKey,
@@ -224,13 +239,20 @@ export async function batchRemoveOwnedNamespaceKeys({
   });
 }
 
-export async function batchRemoveAllFromNamespace(namespace) {
-  const allDataInNamespace = await localStorage.getAllItems(namespace);
+export async function batchRemoveAllFromNamespaceForStorage(
+  namespace: string,
+  storage: Storage
+) {
+  const allDataInNamespace = await storage.getAllItems(namespace);
   const keysToRemove = Object.keys(allDataInNamespace);
 
-  const dataToRemove = {
+  const dataToRemove: StorageValuesToRemove = {
     [namespace]: keysToRemove,
   };
 
-  await batchRemoveFromLocalStorage(dataToRemove);
+  await batchRemoveFromStorage(dataToRemove, storage);
+}
+
+export async function batchRemoveAllFromNamespace(namespace: string) {
+  await batchRemoveAllFromNamespaceForStorage(namespace, localStorage);
 }