@applicaster/zapp-react-native-utils 16.0.0-alpha.3683430391 → 16.0.0-alpha.3693224284

package/reactHooks/navigation/useRoute.ts

@@ -50,14 +50,18 @@ export const useRoute = (
   const rivers = useRivers();
   const contentTypes = useContentTypes();
 
-  const modalState = useModalStoreState();
-
-  const modalScreenData = modalState.screen;
-
+  // useRoute runs in every cell, so both modal stores are subscribed to only on
+  // the routes that actually read them. Off those routes the selectors return a
+  // stable reference, which keeps an unrelated modal opening or closing from
+  // re-rendering the whole tree.
   const hookModalScreenData = useHookModalScreenData(
     !isHookModalPathname(pathname)
   );
 
+  const modalState = useModalStoreState(!isModalPathname(pathname));
+
+  const modalScreenData = modalState.screen;
+
   const videoModalScreenData =
     navigator?.videoModalState?.item &&
     legacyScreenData(
@@ -80,7 +84,20 @@ export const useRoute = (
   // if path is hook grab screenData from screenData
 
   if (isModalPathname(pathname)) {
-    const screenData = modalScreenData ?? ({} as ZappEntry);
+    if (!modalScreenData) {
+      return { screenData: {} as ZappEntry, pathname };
+    }
+
+    // Mirror the pushed-screen shape ({ ...entry, targetScreen }) so a screen
+    // presented as a modal reads its entry the same way it would when
+    // navigated to, instead of only seeing the bare river.
+    const screenData = legacyScreenData(
+      {
+        screen: modalScreenData,
+        entry: modalState.props?.entry as NavigatorEntry,
+      },
+      plugins
+    );
 
     return { screenData, pathname };
   }

package/reactHooks/usePluginConfiguration.ts

@@ -1,4 +1,3 @@
-import * as R from "ramda";
 import { useMemo } from "react";
 
 import { usePlugins } from "@applicaster/zapp-react-native-redux/hooks";
@@ -6,7 +5,8 @@ import { usePlugins } from "@applicaster/zapp-react-native-redux/hooks";
 // importing this way prevents typescript packages importing from this
 // file to go crazy reporting errors on JS
 import { populateConfigurationValues } from "@applicaster/zapp-react-native-utils/configurationUtils";
-import { useLocalizedStrings } from "../localizationUtils";
+import { getLocalizedStrings, useLocalizedStrings } from "../localizationUtils";
+import { isNil, pathOr } from "../utils";
 
 const populateFields = (
   data,
@@ -14,21 +14,80 @@ const populateFields = (
   pathToValues: string | string[] = "configuration",
   skipDefaults = false
 ) =>
-  R.compose(
-    (config) =>
-      populateConfigurationValues(manifestFields, config, skipDefaults),
-    R.pathOr({}, R.unless(Array.isArray, Array)(pathToValues))
-  )(data);
+  populateConfigurationValues(
+    manifestFields,
+    pathOr({}, pathToValues, data),
+    skipDefaults
+  );
 
 export function parsePluginConfiguration(plugin, manifest) {
   return populateFields(plugin, manifest.custom_configuration_fields);
 }
 
-export function usePluginConfiguration<T, S>(identifier, manifest) {
+const getDefaultLocalizations = (manifest) =>
+  manifest?.localizations?.fields?.reduce(
+    (defaults, { key, initial_value }) => ({
+      en: { ...defaults.en, [key]: initial_value },
+    }),
+    { en: {} }
+  ) || {};
+
+const isPlainObject = (value) =>
+  Object.prototype.toString.call(value) === "[object Object]";
+
+// Deep merge where configured values win, except nil ones (defaults fill the gaps)
+export const mergeLocalizations = (configured, defaults) => {
+  if (!isPlainObject(configured)) return { ...defaults };
+  if (!isPlainObject(defaults)) return { ...configured };
+
+  // Configured keys first, as R.mergeDeepWith: the first language is the fallback
+  return Object.keys({ ...configured, ...defaults }).reduce((merged, key) => {
+    const left = configured[key];
+    const right = defaults[key];
+
+    if (!(key in defaults)) {
+      merged[key] = left;
+    } else if (!(key in configured)) {
+      merged[key] = right;
+    } else if (isPlainObject(left) && isPlainObject(right)) {
+      merged[key] = mergeLocalizations(left, right);
+    } else {
+      merged[key] = isNil(left) ? right : left;
+    }
+
+    return merged;
+  }, {});
+};
+
+/**
+ * usePluginConfiguration outside React: the same result, read once instead of subscribed.
+ */
+export function getPluginConfiguration<T = any, S = Record<string, any>>(
+  plugin,
+  manifest?: any
+): { configurationFields: T; localizations: S } {
+  return {
+    configurationFields: populateFields(
+      plugin,
+      manifest?.custom_configuration_fields
+    ),
+    localizations: getLocalizedStrings(
+      mergeLocalizations(
+        plugin?.configuration?.localizations,
+        getDefaultLocalizations(manifest)
+      )
+    ),
+  };
+}
+
+export function usePluginConfiguration<T = any, S = Record<string, any>>(
+  identifier: string,
+  manifest?: any
+) {
   const plugins = usePlugins();
 
   const plugin = useMemo(
-    () => R.find(R.propEq("identifier", identifier), plugins),
+    () => plugins?.find((item) => item?.identifier === identifier),
     [plugins, identifier]
   );
 
@@ -37,29 +96,20 @@ export function usePluginConfiguration<T, S>(identifier, manifest) {
     [plugin, manifest]
   );
 
-  const defaultLocalizations = useMemo(() => {
-    return (
-      manifest?.localizations?.fields?.reduce(
-        (defaults, { key, initial_value }) =>
-          R.assocPath(["en", key], initial_value, defaults),
-        { en: {} }
-      ) || {}
-    );
-  }, [manifest]);
-
-  const localizationsParams = useMemo(() => {
-    return {
-      localizations: R.mergeDeepWith(
-        (left, right) => {
-          if (R.isNil(left)) return right;
+  const defaultLocalizations = useMemo(
+    () => getDefaultLocalizations(manifest),
+    [manifest]
+  );
 
-          return left;
-        },
+  const localizationsParams = useMemo(
+    () => ({
+      localizations: mergeLocalizations(
         plugin?.configuration?.localizations,
         defaultLocalizations
       ),
-    };
-  }, [plugin?.configuration?.localizations, defaultLocalizations]);
+    }),
+    [plugin?.configuration?.localizations, defaultLocalizations]
+  );
 
   const localizations: S = useLocalizedStrings(localizationsParams);
 
@@ -102,29 +152,20 @@ export function useLayoutConfiguration<
     "localizations",
   ];
 
-  const defaultLocalizations = useMemo(() => {
-    return (
-      manifest?.localizations?.fields?.reduce(
-        (defaults, { key, initial_value }) =>
-          R.assocPath(["en", key], initial_value, defaults),
-        { en: {} }
-      ) || {}
-    );
-  }, [manifest]);
-
-  const localizationsParams = useMemo(() => {
-    return {
-      localizations: R.mergeDeepWith(
-        (left, right) => {
-          if (R.isNil(left)) return right;
+  const defaultLocalizations = useMemo(
+    () => getDefaultLocalizations(manifest),
+    [manifest]
+  );
 
-          return left;
-        },
+  const localizationsParams = useMemo(
+    () => ({
+      localizations: mergeLocalizations(
         layoutData?.localizations,
         defaultLocalizations
       ),
-    };
-  }, [layoutData?.localizations, defaultLocalizations]);
+    }),
+    [layoutData?.localizations, defaultLocalizations]
+  );
 
   // Always call useLocalizedStrings regardless of whether localizations is in the keys
   const localizations: L = useLocalizedStrings(localizationsParams);

package/reactHooks/utils/__tests__/index.test.js

@@ -1,5 +1,5 @@
-import { usePrevious, useIsInitialRender } from "../";
-import { renderHook, cleanup } from "@testing-library/react-native";
+import { usePrevious, useIsInitialRender, useForceUpdate } from "../";
+import { renderHook, cleanup, act } from "@testing-library/react-native";
 
 describe("usePrevious", () => {
   it("renders", () => {
@@ -49,3 +49,23 @@ describe("useIsInitialRender", () => {
     expect(result.current).toBe(false);
   });
 });
+
+describe("useForceUpdate", () => {
+  it("forces component to re-render when called", () => {
+    let renderCount = 0;
+
+    const { result } = renderHook(() => {
+      renderCount++;
+
+      return useForceUpdate();
+    });
+
+    expect(renderCount).toBe(1);
+
+    act(() => {
+      result.current();
+    });
+
+    expect(renderCount).toBe(2);
+  });
+});

package/reactHooks/utils/index.ts

@@ -1,4 +1,4 @@
-import { useEffect, useRef } from "react";
+import { useEffect, useReducer, useRef } from "react";
 
 /**
  * This hook returns a previous value that was passed to it.
@@ -31,6 +31,16 @@ export const useIsInitialRender = (): boolean => {
   return isInitialRenderRef.current;
 };
 
+/**
+ * Returns a function that forces a re-render of the component when invoked.
+ * @return {() => void}
+ */
+export const useForceUpdate = (): (() => void) => {
+  const [, forceUpdate] = useReducer((n: number) => n + 1, 0);
+
+  return forceUpdate;
+};
+
 export const checkIsLocalFeed = (feedUrl) => feedUrl?.startsWith("pipesv2://");
 
 export const shouldDispatchData = (

package/riverComponetsMeasurementProvider/index.tsx

@@ -34,6 +34,7 @@ type Props = {
 type ItemProps = {
   children: React.ReactNode;
   index: number;
+  testID?: string;
 };
 
 type MeasurementContext = {
@@ -153,11 +154,12 @@ export const ScreenLoadingMeasurements = ({
 export const ScreenLoadingMeasurementsListItemWrapper = ({
   children,
   index,
+  testID,
 }: ItemProps) => {
   const { onLayout } = React.useContext(MeasurementsSettersContext);
 
   return (
-    <View style={styles.container} onLayout={onLayout?.(index)}>
+    <View style={styles.container} onLayout={onLayout?.(index)} testID={testID}>
       {children}
     </View>
   );

package/uiActionsRegistrator/__tests__/resolveActionIdentifiers.test.ts

@@ -0,0 +1,93 @@
+import {
+  parseActionIdentifiers,
+  resolveActionIdentifiers,
+} from "../resolveActionIdentifiers";
+import { uiActionsRegistry } from "../registry";
+
+const action = (identifier: string) =>
+  ({ identifier, action: { invokeAction: jest.fn() } }) as any;
+
+describe("parseActionIdentifiers", () => {
+  it("parses comma-separated identifiers", () => {
+    expect(parseActionIdentifiers(" a, b , ,c ")).toEqual(["a", "b", "c"]);
+  });
+
+  it("parses identifier arrays", () => {
+    expect(parseActionIdentifiers([" a ", "", "b", "  ", "c"])).toEqual([
+      "a",
+      "b",
+      "c",
+    ]);
+  });
+
+  it("returns empty array for nil config", () => {
+    expect(parseActionIdentifiers(null)).toEqual([]);
+    expect(parseActionIdentifiers(undefined)).toEqual([]);
+  });
+});
+
+describe("resolveActionIdentifiers", () => {
+  const entry = { id: "entry-1" } as any;
+
+  beforeEach(() => {
+    jest
+      .spyOn(uiActionsRegistry, "getActions")
+      .mockImplementation((identifier) => [action(identifier)] as any);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it("resolves through registry by default", () => {
+    const result = resolveActionIdentifiers({
+      identifiers: "favorites,share",
+      entry,
+    });
+
+    expect(result.map((item) => item.identifier)).toEqual([
+      "favorites",
+      "share",
+    ]);
+
+    expect(uiActionsRegistry.getActions).toHaveBeenCalledWith(
+      "favorites",
+      entry
+    );
+
+    expect(uiActionsRegistry.getActions).toHaveBeenCalledWith("share", entry);
+  });
+
+  it("expands entry_actions through the caller, not the registry", () => {
+    const expanded = [action("entry_action_0"), action("entry_action_1")];
+    const expandEntryActions = jest.fn(() => expanded);
+
+    const unregister = uiActionsRegistry.registerAction("share", {
+      invokeAction: jest.fn(),
+    });
+
+    try {
+      const result = resolveActionIdentifiers({
+        identifiers: "entry_actions,share",
+        entry,
+        expandEntryActions,
+      });
+
+      expect(expandEntryActions).toHaveBeenCalledWith(entry);
+
+      expect(result.map((item) => item.identifier)).toEqual([
+        "entry_action_0",
+        "entry_action_1",
+        "share",
+      ]);
+    } finally {
+      unregister();
+    }
+  });
+
+  it("resolves nothing for entry_actions when the caller cannot expand it", () => {
+    expect(
+      resolveActionIdentifiers({ identifiers: "entry_actions", entry })
+    ).toEqual([]);
+  });
+});

package/uiActionsRegistrator/__tests__/subscribe.test.ts

@@ -0,0 +1,133 @@
+import { isActionAvailableFor, uiActionsRegistry } from "../registry";
+
+const value = { invokeAction: jest.fn() };
+
+describe("uiActionsRegistry.subscribe", () => {
+  it("fires on registration and on unregistration", () => {
+    const listener = jest.fn();
+    const unsubscribe = uiActionsRegistry.subscribe(listener);
+
+    const unregister = uiActionsRegistry.registerAction("late-action", value);
+
+    expect(listener).toHaveBeenCalledTimes(1);
+
+    unregister();
+
+    expect(listener).toHaveBeenCalledTimes(2);
+
+    unsubscribe();
+  });
+
+  it("lets a listener see the action it was told about", () => {
+    let seen: string[] = [];
+
+    const unsubscribe = uiActionsRegistry.subscribe(() => {
+      seen = uiActionsRegistry
+        .getActions("late-action", { id: "e1" } as any)
+        .map((item) => item.identifier);
+    });
+
+    const unregister = uiActionsRegistry.registerAction("late-action", value);
+
+    expect(seen).toEqual(["late-action"]);
+
+    unregister();
+    unsubscribe();
+  });
+
+  it("stops calling a listener once unsubscribed", () => {
+    const listener = jest.fn();
+
+    uiActionsRegistry.subscribe(listener)();
+
+    uiActionsRegistry.registerAction("another-action", value)();
+
+    expect(listener).not.toHaveBeenCalled();
+  });
+
+  it("survives a listener that unsubscribes itself while being notified", () => {
+    const other = jest.fn();
+
+    const unsubscribeOther = uiActionsRegistry.subscribe(other);
+
+    const unsubscribeSelf = uiActionsRegistry.subscribe(() => {
+      unsubscribeSelf();
+    });
+
+    expect(() =>
+      uiActionsRegistry.registerAction("self-removing", value)()
+    ).not.toThrow();
+
+    expect(other).toHaveBeenCalled();
+
+    unsubscribeOther();
+  });
+});
+
+describe("isActionAvailableFor", () => {
+  const entry = { id: "e1" } as any;
+
+  it("shows an action that states no opinion", () => {
+    expect(isActionAvailableFor({ invokeAction: jest.fn() }, entry)).toBe(true);
+  });
+
+  it.each([
+    ["isSupportDownloads"],
+    ["isActionSupported"],
+    ["isActionAvailable"],
+  ])("honours %s", (predicate) => {
+    expect(
+      isActionAvailableFor(
+        { invokeAction: jest.fn(), [predicate]: () => false } as any,
+        entry
+      )
+    ).toBe(false);
+  });
+
+  it("asks only the first predicate the action defines", () => {
+    const isActionAvailable = jest.fn(() => true);
+
+    expect(
+      isActionAvailableFor(
+        {
+          invokeAction: jest.fn(),
+          isSupportDownloads: () => false,
+          isActionAvailable,
+        } as any,
+        entry
+      )
+    ).toBe(false);
+
+    expect(isActionAvailable).not.toHaveBeenCalled();
+  });
+
+  it("treats a missing action as unavailable-free", () => {
+    expect(isActionAvailableFor(undefined, entry)).toBe(true);
+  });
+});
+
+describe("uiActionsRegistry.notifyProviderChanged", () => {
+  it("notifies subscribers for a registered provider", () => {
+    const unregister = uiActionsRegistry.registerAction("live-action", value);
+    const listener = jest.fn();
+    const unsubscribe = uiActionsRegistry.subscribe(listener);
+
+    uiActionsRegistry.notifyProviderChanged("live-action");
+
+    expect(listener).toHaveBeenCalledTimes(1);
+
+    unsubscribe();
+    unregister();
+  });
+
+  it("ignores names that are not registered", () => {
+    const listener = jest.fn();
+    const unsubscribe = uiActionsRegistry.subscribe(listener);
+
+    uiActionsRegistry.notifyProviderChanged("unknown-action");
+
+    expect(listener).not.toHaveBeenCalled();
+
+    unsubscribe();
+  });
+});

package/uiActionsRegistrator/__tests__/usableActionItems.test.ts

@@ -0,0 +1,52 @@
+import { usableActionItems } from "../usableActionItems";
+
+const action = (identifier: string) =>
+  ({ identifier, action: { invokeAction: jest.fn() } }) as any;
+
+describe("usableActionItems", () => {
+  it("keeps a usable list untouched, in order", () => {
+    const base = [action("share"), action("favorites")];
+
+    expect(usableActionItems(base).map((item) => item.identifier)).toEqual([
+      "share",
+      "favorites",
+    ]);
+  });
+
+  it("keeps the first of a repeated identifier", () => {
+    const firstShare = action("share");
+    const secondShare = action("share");
+
+    const result = usableActionItems([
+      firstShare,
+      action("favorites"),
+      secondShare,
+    ]);
+
+    expect(result.map((item) => item.identifier)).toEqual([
+      "share",
+      "favorites",
+    ]);
+
+    expect(result[0]).toBe(firstShare);
+  });
+
+  it("drops items that cannot be invoked or have no identifier", () => {
+    const result = usableActionItems([
+      action("share"),
+      { identifier: "blank" } as any,
+      { identifier: "no-invoke", action: {} } as any,
+      { action: { invokeAction: jest.fn() } } as any,
+      action("entry_action_0"),
+    ]);
+
+    expect(result.map((item) => item.identifier)).toEqual([
+      "share",
+      "entry_action_0",
+    ]);
+  });
+
+  it("tolerates a missing list", () => {
+    expect(usableActionItems(undefined as any)).toEqual([]);
+  });
+});