@applicaster/zapp-react-native-utils 15.0.0-alpha.8621453569 → 15.0.0-alpha.8680244503

package/utils/__tests__/selectors.test.ts

@@ -0,0 +1,124 @@
+import {
+  createPluginsByPathSelector,
+  createPluginsByModuleSelector,
+  combinePluginSelectors,
+} from "../selectors";
+
+describe("Plugin Selectors", () => {
+  const mockPlugins = [
+    {
+      identifier: "plugin1",
+      module: {
+        urlScheme: { host: "test" },
+        player: { type: "default" },
+      },
+      customField: true,
+    },
+    {
+      identifier: "plugin2",
+      module: {
+        urlScheme: { host: "other" },
+      },
+    },
+    {
+      identifier: "plugin3",
+      module: {
+        player: { type: "custom" },
+      },
+    },
+  ];
+
+  const mockState = {
+    plugins: mockPlugins,
+  };
+
+  describe("createPluginsByPathSelector", () => {
+    it("filters plugins by string path", () => {
+      const selector = createPluginsByPathSelector("customField");
+      const result = selector(mockState);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].identifier).toBe("plugin1");
+    });
+
+    it("filters plugins by array path", () => {
+      const selector = createPluginsByPathSelector(["module", "urlScheme"]);
+      const result = selector(mockState);
+
+      expect(result).toHaveLength(2);
+      expect(result.map((p) => p.identifier)).toEqual(["plugin1", "plugin2"]);
+    });
+
+    it("handles missing plugins array", () => {
+      const selector = createPluginsByPathSelector("customField");
+      const result = selector({});
+
+      expect(result).toEqual([]);
+    });
+
+    it("handles non-existent path", () => {
+      const selector = createPluginsByPathSelector("nonexistent");
+      const result = selector(mockState);
+
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe("createPluginsByModuleSelector", () => {
+    it("filters plugins by module path", () => {
+      const selector = createPluginsByModuleSelector("player");
+      const result = selector(mockState);
+
+      expect(result).toHaveLength(2);
+      expect(result.map((p) => p.identifier)).toEqual(["plugin1", "plugin3"]);
+    });
+
+    it("handles non-existent module", () => {
+      const selector = createPluginsByModuleSelector("nonexistent");
+      const result = selector(mockState);
+
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe("combinePluginSelectors", () => {
+    it("combines multiple selectors with AND logic", () => {
+      const urlSchemeSelector = createPluginsByModuleSelector("urlScheme");
+      const playerSelector = createPluginsByModuleSelector("player");
+
+      const combinedSelector = combinePluginSelectors(
+        urlSchemeSelector,
+        playerSelector
+      );
+
+      const result = combinedSelector(mockState);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].identifier).toBe("plugin1");
+    });
+
+    it("returns empty array when no plugins match all conditions", () => {
+      const urlSchemeSelector = createPluginsByModuleSelector("urlScheme");
+      const customSelector = createPluginsByPathSelector("nonexistent");
+
+      const combinedSelector = combinePluginSelectors(
+        urlSchemeSelector,
+        customSelector
+      );
+
+      const result = combinedSelector(mockState);
+
+      expect(result).toEqual([]);
+    });
+
+    it("handles empty state", () => {
+      const selector = combinePluginSelectors(
+        createPluginsByModuleSelector("urlScheme")
+      );
+
+      const result = selector({});
+
+      expect(result).toEqual([]);
+    });
+  });
+});

package/utils/index.ts

@@ -40,5 +40,8 @@ export {
   uniqWith,
   flowRight as compose,
   partial,
+  clamp,
   reverse,
+  set,
+  compact,
 } from "lodash";

package/utils/selectors.ts

@@ -0,0 +1,46 @@
+import { get } from "lodash";
+
+export type Selector<T> = (state: any) => T;
+
+/**
+ * Creates a selector for filtering plugins by path
+ * @param path - Path to check in plugin. Can be a dot notation string or array
+ * @returns A selector function that returns matching plugins
+ */
+export const createPluginsByPathSelector = (
+  path: string | string[]
+): Selector<any[]> => {
+  return (state: any) => {
+    const plugins = state.plugins || [];
+
+    return plugins.filter((plugin: any) => get(plugin, path));
+  };
+};
+
+/**
+ * Creates a selector for filtering plugins by module path
+ * @param modulePath - Module path to check in plugin (e.g., "urlScheme", "player")
+ * @returns A selector function that returns plugins with specified module
+ */
+export const createPluginsByModuleSelector = (
+  modulePath: string
+): Selector<any[]> => {
+  return createPluginsByPathSelector(["module", modulePath]);
+};
+
+/**
+ * Creates a selector that combines multiple plugin selectors
+ * @param selectors - Array of plugin selectors to combine
+ * @returns A selector function that returns plugins matching all conditions
+ */
+export const combinePluginSelectors = (
+  ...selectors: Selector<any[]>[]
+): Selector<any[]> => {
+  return (state: any) => {
+    return selectors.reduce((filtered, selector) => {
+      const selected = selector(state);
+
+      return filtered.filter((plugin) => selected.includes(plugin));
+    }, state.plugins || []);
+  };
+};

package/zappFrameworkUtils/HookCallback/callbackNavigationAction.ts

@@ -1,6 +1,6 @@
 import { useNavigation, useRivers, useScreenContext } from "../../reactHooks";
 import { createLogger } from "../../logger";
-import { useCallback, useMemo } from "react";
+import { useCallback, useMemo, useRef, useEffect } from "react";
 
 export enum NavigationCallbackOptions {
   DEFAULT = "default",
@@ -17,6 +17,7 @@ export enum ResultType {
 export type CallbackResult = hookCallbackArgs & {
   options?: {
     resultType?: ResultType;
+    navigator?: QuickBrickAppNavigator;
   };
 };
 
@@ -135,6 +136,12 @@ export const useCallbackNavigationAction = (
   const rivers = useRivers();
   const screenContext = useScreenContext();
 
+  const navigationRef = useRef(navigation);
+
+  useEffect(() => {
+    navigationRef.current = navigation;
+  }, [navigation]);
+
   const overrideCallbackFromComponent = useMemo(() => {
     log_verbose(`${LogPrefix}: overridden callbackAction by component`);
 
@@ -177,11 +184,13 @@ export const useCallbackNavigationAction = (
       }
 
       hookCallback?.({ ...args, success: false, cancelled: true });
+      const currentNavigation = navigationRef.current;
 
       switch (data.action) {
         case NavigationCallbackOptions.GO_BACK: {
-          if (navigation.canGoBack()) {
-            navigation.goBack();
+          if (currentNavigation.canGoBack()) {
+            currentNavigation.goBack();
+
             log_info(`${LogPrefix} performing 'GO BACK' action`);
           } else {
             log_info(`${LogPrefix} cannot perform 'GO BACK' action — ignoring`);
@@ -191,7 +200,7 @@ export const useCallbackNavigationAction = (
         }
 
         case NavigationCallbackOptions.GO_HOME: {
-          navigation.goHome();
+          currentNavigation.goHome();
           log_info(`${LogPrefix} performing 'GO HOME' action`);
           break;
         }
@@ -207,7 +216,7 @@ export const useCallbackNavigationAction = (
           const screen = rivers[screenId];
 
           if (screen) {
-            navigation.replace(screen);
+            currentNavigation.replace(screen);
 
             log_info(
               `${LogPrefix} performing 'GO TO SCREEN' action to screen: ${screenId}`
@@ -224,7 +233,7 @@ export const useCallbackNavigationAction = (
         }
       }
     },
-    [item, navigation, rivers]
+    [item, rivers]
   );
 
   return overrideCallbackFromComponent || callbackAction;