@applicaster/quick-brick-core 16.0.0-alpha.3112220329 → 16.0.0-alpha.3202041045

package/App/ActionsProvider/LegacyActionsRegistryAdapter.tsx

@@ -66,6 +66,22 @@ function LegacyActionBridge({ plugin }: { plugin: LegacyActionPlugin }) {
     };
   }, [plugin.identifier]);
 
+  // Consumers resolve a snapshot of `value`; when the plugin publishes a new
+  // one (e.g. cast devices found), make them re-resolve so availability
+  // predicates are not read from a stale value. Registration already
+  // notifies, so the first render is skipped.
+  const isFirstValueRef = React.useRef(true);
+
+  React.useEffect(() => {
+    if (isFirstValueRef.current) {
+      isFirstValueRef.current = false;
+
+      return;
+    }
+
+    uiActionsRegistry.notifyProviderChanged(plugin.identifier);
+  }, [value, plugin.identifier]);
+
   return null;
 }
 

package/App/ActionsProvider/__tests__/LegacyActionsRegistryAdapter.test.tsx

@@ -0,0 +1,64 @@
+import React from "react";
+import { render } from "@testing-library/react-native";
+import { uiActionsRegistry } from "@applicaster/zapp-react-native-utils/uiActionsRegistrator";
+import { LegacyActionsRegistryAdapter } from "../LegacyActionsRegistryAdapter";
+
+const CastContext = React.createContext<any>(null);
+
+const plugin = {
+  identifier: "cast-action-test",
+  module: { context: CastContext },
+};
+
+const renderWithValue = (value) => (
+  <CastContext.Provider value={value}>
+    <LegacyActionsRegistryAdapter actionPlugins={{ cast: plugin } as any} />
+  </CastContext.Provider>
+);
+
+describe("LegacyActionsRegistryAdapter", () => {
+  it("makes consumers re-resolve when the plugin publishes a new value", () => {
+    const noDevices = { isActionAvailable: () => false };
+    const devicesFound = { isActionAvailable: () => true };
+
+    const { rerender, unmount } = render(renderWithValue(noDevices));
+
+    // what a consumer resolved at first paint
+    expect(
+      uiActionsRegistry
+        .getAction("cast-action-test")
+        ?.isActionAvailable?.({} as any)
+    ).toBe(false);
+
+    const listener = jest.fn();
+    const unsubscribe = uiActionsRegistry.subscribe(listener);
+
+    rerender(renderWithValue(devicesFound));
+
+    expect(listener).toHaveBeenCalledTimes(1);
+
+    expect(
+      uiActionsRegistry
+        .getAction("cast-action-test")
+        ?.isActionAvailable?.({} as any)
+    ).toBe(true);
+
+    unsubscribe();
+    unmount();
+  });
+
+  it("does not notify again when the value is unchanged", () => {
+    const stable = { isActionAvailable: () => true };
+    const { rerender, unmount } = render(renderWithValue(stable));
+
+    const listener = jest.fn();
+    const unsubscribe = uiActionsRegistry.subscribe(listener);
+
+    rerender(renderWithValue(stable));
+
+    expect(listener).not.toHaveBeenCalled();
+
+    unsubscribe();
+    unmount();
+  });
+});

package/App/ModalProvider/ModalContent.tsx

@@ -1,7 +1,6 @@
 import React from "react";
 
 import { View, StyleSheet } from "react-native";
-import { useSafeAreaInsets } from "react-native-safe-area-context";
 
 import { ScreenResolver } from "@applicaster/zapp-react-native-ui-components/Components/ScreenResolver";
 
@@ -18,8 +17,6 @@ const styles = StyleSheet.create({
 export function ModalContent(props: Props) {
   const { modalScreenProps } = props;
 
-  const insets = useSafeAreaInsets();
-
   if (modalScreenProps?.screenData?.modalBottomSheetContentProps) {
     const { ModalBottomSheetContent, modalBottomSheetContentProps } =
       modalScreenProps?.screenData || {};
@@ -34,19 +31,9 @@ export function ModalContent(props: Props) {
 
   return (
     // A presented screen fills the window, including the status bar and home
-    // indicator. Inset it so chrome it draws at its own edges — a close button,
-    // for example — stays inside the tappable area.
-    <View
-      style={[
-        styles.container,
-        {
-          paddingTop: insets.top,
-          paddingBottom: insets.bottom,
-          paddingLeft: insets.left,
-          paddingRight: insets.right,
-        },
-      ]}
-    >
+    // indicator. The modal wraps it in its own SafeAreaProvider, so the screen
+    // reads the real insets itself and places its own chrome inside them.
+    <View style={styles.container}>
       <ScreenResolver {...modalScreenProps} />
     </View>
   );

package/App/ModalProvider/__tests__/ModalContent.test.tsx

@@ -6,10 +6,6 @@ import { ModalContent } from "../ModalContent";
 
 jest.mock("../ModalBottomSheet", () => ({ ModalBottomSheet: () => null }));
 
-jest.mock("react-native-safe-area-context", () => ({
-  useSafeAreaInsets: () => ({ top: 59, bottom: 34, left: 0, right: 0 }),
-}));
-
 jest.mock(
   "@applicaster/zapp-react-native-ui-components/Components/ScreenResolver",
   () => ({ ScreenResolver: () => null })
@@ -18,15 +14,14 @@ jest.mock(
 const flatStyle = (tree: any) => StyleSheet.flatten(tree.props.style);
 
 describe("ModalContent", () => {
-  it("insets a presented screen by the safe area so its chrome stays tappable", () => {
+  it("lets a presented screen fill the modal, leaving the safe area to the screen", () => {
     const tree = render(
       <ModalContent modalScreenProps={{ screenId: "river-1" }} />
     ).toJSON();
 
-    expect(flatStyle(tree)).toMatchObject({
-      paddingTop: 59,
-      paddingBottom: 34,
-    });
+    // The modal provides a SafeAreaProvider instead, so the presented screen
+    // reads the real insets itself rather than being padded from the outside.
+    expect(flatStyle(tree)).toEqual({ flex: 1 });
   });
 
   it("leaves a bottom sheet full-bleed", () => {

package/App/ModalProvider/__tests__/index.test.tsx

@@ -11,6 +11,9 @@ import { ModalProvider } from "../";
  */
 const mockSeenScreenData: any[] = [];
 
+/** Records the `initialMetrics` each SafeAreaProvider the modal renders got. */
+const mockSafeAreaProviderMetrics: any[] = [];
+
 jest.mock(
   "@applicaster/zapp-react-native-ui-components/Components/ScreenResolver",
   () => {
@@ -43,6 +46,14 @@ jest.mock("../ModalBottomSheet", () => ({ ModalBottomSheet: () => null }));
 
 jest.mock("react-native-safe-area-context", () => ({
   useSafeAreaInsets: () => ({ top: 0, bottom: 0, left: 0, right: 0 }),
+  // A modal renders in its own native window, so it needs its own provider
+  // seeded with the window metrics; without them insets read as zero inside.
+  initialWindowMetrics: { insets: { top: 59, bottom: 34, left: 0, right: 0 } },
+  SafeAreaProvider: ({ children, initialMetrics }: any) => {
+    mockSafeAreaProviderMetrics.push(initialMetrics);
+
+    return children;
+  },
 }));
 
 const river = { id: "river-parent-lock", type: "parent_lock" } as any;
@@ -54,6 +65,7 @@ const seen = () => mockSeenScreenData[mockSeenScreenData.length - 1];
 describe("ModalProvider", () => {
   beforeEach(() => {
     mockSeenScreenData.length = 0;
+    mockSafeAreaProviderMetrics.length = 0;
     modalStore.getState().dismissModal();
   });
 
@@ -72,4 +84,16 @@ describe("ModalProvider", () => {
 
     expect(seen()).toMatchObject({ screen: river });
   });
+
+  it("seeds the presented screen's safe area with the window metrics", () => {
+    const { initialWindowMetrics } = require("react-native-safe-area-context");
+
+    modalStore.getState().openModal({ item: river });
+
+    render(<ModalProvider />);
+
+    expect(mockSafeAreaProviderMetrics).toEqual(
+      expect.arrayContaining([initialWindowMetrics])
+    );
+  });
 });

package/App/ModalProvider/index.tsx

@@ -1,5 +1,10 @@
 import * as React from "react";
 
+import {
+  initialWindowMetrics,
+  SafeAreaProvider,
+} from "react-native-safe-area-context";
+
 import { ModalPresenter } from "./ModalPresenter";
 import { ModalContent } from "./ModalContent";
 import { ModalChildrenWrapper } from "./ModalChildrenWrapper";
@@ -62,9 +67,11 @@ export function ModalProvider() {
             {...modalState?.options}
             statusBarTranslucent
           >
-            <ModalChildrenWrapper>
-              <ModalContent modalScreenProps={modalScreenProps} />
-            </ModalChildrenWrapper>
+            <SafeAreaProvider initialMetrics={initialWindowMetrics}>
+              <ModalChildrenWrapper>
+                <ModalContent modalScreenProps={modalScreenProps} />
+              </ModalChildrenWrapper>
+            </SafeAreaProvider>
           </ModalPresenter>
         </ScreenContextProvider>
       </ScreenDataContext.Provider>

package/App/NavigationProvider/NavigationProvider.tsx

@@ -13,6 +13,8 @@ import {
   useGetScreenOrientation,
 } from "@applicaster/zapp-react-native-utils/appUtils/orientationHelper";
 import { focusManager } from "@applicaster/zapp-react-native-utils/focusManager/FocusManager";
+import { setXrayNavigator } from "@applicaster/zapp-react-native-utils/navigationUtils/xrayNavigator";
+import { registerNavToolbox } from "./navToolbox";
 
 import reducer, {
   ACTIONS,
@@ -243,6 +245,10 @@ export function NavigationProvider({ children }: Props) {
     playNextOverlayState.current = state;
   };
 
+  // The play-next overlay owns remote focus while it is visible, so key
+  // handling (InteractionManager) needs to be able to ask for it.
+  const getPlayNextOverlay = () => playNextOverlayState.current ?? null;
+
   const setNestedScreenContent = (entry: ZappEntry, screenId: string) => {
     const screen = rivers[screenId];
     const parent = findParent(context, navigator.currentRoute);
@@ -349,10 +355,7 @@ export function NavigationProvider({ children }: Props) {
           state: firstRoute.state,
         };
 
-        if (
-          stateForBack?.state?.entry &&
-          "home" in stateForBack?.state?.entry
-        ) {
+        if (stateForBack?.state?.entry?.home) {
           goHome();
         } else {
           dispatch(back(stateForBack));
@@ -759,11 +762,11 @@ export function NavigationProvider({ children }: Props) {
   const getStackForPathname = (
     pathname: string
   ): NavigationScreenState | undefined => {
-    const stack = [...state?.stack?.mainStack];
-
-    const currentStack = stack.find(({ route }) => route === pathname);
-
-    return currentStack;
+    // Topmost match: the active screen if a route is on the stack twice.
+    return R.findLast(
+      ({ route }) => route === pathname,
+      state?.stack?.mainStack ?? []
+    );
   };
 
   const navigator: QuickBrickAppNavigator = React.useMemo(
@@ -777,6 +780,7 @@ export function NavigationProvider({ children }: Props) {
       replace: replaceItem,
       setNestedScreenContent,
       setPlayNextOverlay,
+      getPlayNextOverlay,
       goHome,
       canGoBack,
       goBack,
@@ -827,6 +831,13 @@ export function NavigationProvider({ children }: Props) {
     navigator.state = state;
   }
 
+  React.useLayoutEffect(() => {
+    setXrayNavigator(navigator);
+    registerNavToolbox();
+
+    return () => setXrayNavigator(undefined);
+  }, [navigator]);
+
   React.useLayoutEffect(() => {
     if (pathname === "/" && appLaunched) {
       goHome(true);

package/App/NavigationProvider/__tests__/navToolbox.test.ts

@@ -0,0 +1,227 @@
+const mockRegister = jest.fn().mockResolvedValue(undefined);
+
+// The X-Ray mock (__mocks__/@applicaster/quick-brick-xray) has no toolbox API: give it one.
+require("@applicaster/quick-brick-xray").registerReactToolbox = mockRegister;
+
+// Required after the toolbox API is in place: loading them can register the player toolbox.
+const {
+  modalStore,
+} = require("@applicaster/zapp-react-native-utils/modalState");
+
+const {
+  setXrayNavigator,
+} = require("@applicaster/zapp-react-native-utils/navigationUtils/xrayNavigator");
+
+const {
+  playerManager,
+} = require("@applicaster/zapp-react-native-utils/appUtils/playerManager");
+
+const { registerNavToolbox } = require("../navToolbox");
+
+const navigator = (overrides = {}) => {
+  const nav = {
+    getPathname: () => "/river/a/river/b",
+    getStack: () => [{ route: "/river/a" }, { route: "/river/a/river/b" }],
+    canGoBack: () => true,
+    goBack: jest.fn(),
+    goHome: jest.fn(),
+    getPlayNextOverlay: () => null,
+    getModalState: () => modalStore.getState().modalState,
+    dismissModal: jest.fn(),
+    videoModalState: { visible: false },
+    minimiseVideoModal: jest.fn(),
+    maximiseVideoModal: jest.fn(),
+    closeVideoModal: jest.fn(),
+    ...overrides,
+  };
+
+  setXrayNavigator(nav as unknown as QuickBrickAppNavigator);
+
+  return nav;
+};
+
+const videoModal = (mode: string) => ({
+  videoModalState: { visible: true, mode, item: { id: "v1", title: "V" } },
+});
+
+const call = (name: string) => {
+  // Other toolboxes (player) may register first.
+  const { tools } = mockRegister.mock.calls.find(
+    ([toolbox]) => toolbox.name === "nav"
+  )[0];
+
+  return tools.find((tool) => tool.name === name).handler({});
+};
+
+describe("navToolbox", () => {
+  beforeAll(() => registerNavToolbox());
+
+  afterEach(() => {
+    modalStore.getState().setModalState({ visible: false, screen: null });
+    jest.restoreAllMocks();
+  });
+
+  it("throws until the NavigationProvider sets the navigator", () => {
+    setXrayNavigator(undefined);
+
+    expect(() => call("stack")).toThrow("Navigation is not available yet");
+  });
+
+  it("goes back one screen", () => {
+    const nav = navigator();
+
+    expect(call("back")).toEqual({ from: "/river/a/river/b", wentBack: true });
+    expect(nav.goBack).toHaveBeenCalledWith(false);
+  });
+
+  it("does not go back from the root", () => {
+    const nav = navigator({ canGoBack: () => false });
+
+    expect(call("back")).toMatchObject({ wentBack: false });
+    expect(nav.goBack).not.toHaveBeenCalled();
+  });
+
+  it("does not pop the screen under a modal or the video modal", () => {
+    const nav = navigator(videoModal("MAXIMIZED"));
+
+    expect(call("back")).toEqual({
+      from: "video-modal/v1",
+      wentBack: false,
+      blockedBy: "video-modal",
+    });
+
+    modalStore.getState().openModal({ item: { id: "m" } });
+
+    expect(call("back")).toMatchObject({ blockedBy: "modal" });
+    expect(nav.goBack).not.toHaveBeenCalled();
+  });
+
+  it("only dismisses Play Next when it shows", () => {
+    const nav = navigator({ getPlayNextOverlay: () => ({}) });
+
+    expect(call("back")).toMatchObject({
+      wentBack: false,
+      dismissed: "playNext",
+    });
+
+    expect(nav.goBack).toHaveBeenCalledWith(false);
+  });
+
+  it("leaves a hook screen to cancel itself", () => {
+    const nav = navigator({ getPathname: () => "/river/a/hooks/login" });
+
+    expect(call("back")).toMatchObject({ wentBack: false, blockedBy: "hook" });
+    expect(nav.goBack).not.toHaveBeenCalled();
+  });
+
+  it("goes home", () => {
+    const nav = navigator();
+
+    expect(call("home")).toEqual({ from: "/river/a/river/b", wentHome: true });
+    expect(nav.goHome).toHaveBeenCalled();
+  });
+
+  it("does not go home under a modal or the video modal", () => {
+    const nav = navigator(videoModal("MAXIMIZED"));
+
+    expect(call("home")).toEqual({
+      from: "video-modal/v1",
+      wentHome: false,
+      blockedBy: "video-modal",
+    });
+
+    modalStore.getState().openModal({ item: { id: "m" } });
+
+    expect(call("home")).toMatchObject({ blockedBy: "modal" });
+    expect(nav.goHome).not.toHaveBeenCalled();
+  });
+
+  it("goes home with the mini player docked", () => {
+    const nav = navigator(videoModal("MINIMIZED"));
+
+    expect(call("home")).toMatchObject({ wentHome: true });
+    expect(nav.goHome).toHaveBeenCalled();
+  });
+
+  it("dismisses the modal store's modal, not the video modal", () => {
+    const nav = navigator(videoModal("MAXIMIZED"));
+
+    expect(() => call("dismissModal")).toThrow("No modal is open");
+
+    modalStore.getState().openModal({ item: { id: "m" } });
+
+    expect(call("dismissModal")).toBe("OK");
+    expect(nav.dismissModal).toHaveBeenCalled();
+  });
+
+  it("minimises only a maximised video modal", () => {
+    const fullscreen = navigator(videoModal("FULLSCREEN"));
+
+    expect(() => call("minimizeVideoModal")).toThrow("mode is FULLSCREEN");
+    expect(fullscreen.minimiseVideoModal).not.toHaveBeenCalled();
+
+    const maximized = navigator(videoModal("MAXIMIZED"));
+
+    call("minimizeVideoModal");
+
+    expect(maximized.minimiseVideoModal).toHaveBeenCalled();
+  });
+
+  it("enters and leaves fullscreen through the player, which also rotates the phone", () => {
+    const invoke = jest.spyOn(playerManager, "invokeHandler");
+    const playerContainer = jest.fn();
+
+    playerManager.on("toggleFullscreen", playerContainer);
+
+    navigator(videoModal("MAXIMIZED"));
+    call("fullscreenVideoModal");
+
+    expect(invoke).toHaveBeenCalledWith("toggleFullscreen", {
+      fullscreen: true,
+    });
+
+    const fullscreen = navigator(videoModal("FULLSCREEN"));
+
+    call("maximizeVideoModal");
+
+    expect(invoke).toHaveBeenCalledWith("toggleFullscreen", {
+      fullscreen: false,
+    });
+
+    expect(fullscreen.maximiseVideoModal).not.toHaveBeenCalled();
+
+    playerManager.removeHandler("toggleFullscreen", playerContainer);
+  });
+
+  it("does not claim fullscreen without a player, or from the mini player", () => {
+    navigator(videoModal("MAXIMIZED"));
+
+    expect(() => call("fullscreenVideoModal")).toThrow("shows no player");
+
+    navigator(videoModal("MINIMIZED"));
+
+    expect(() => call("fullscreenVideoModal")).toThrow("mode is MINIMIZED");
+  });
+
+  it("expands the mini player", () => {
+    const nav = navigator(videoModal("MINIMIZED"));
+
+    call("maximizeVideoModal");
+
+    expect(nav.maximiseVideoModal).toHaveBeenCalled();
+  });
+
+  it("reports the video modal", () => {
+    navigator(videoModal("MINIMIZED"));
+
+    expect(call("videoModal")).toMatchObject({
+      visible: true,
+      mode: "MINIMIZED",
+      entry: { id: "v1", title: "V" },
+    });
+
+    navigator();
+
+    expect(call("videoModal")).toMatchObject({ visible: false });
+  });
+});

package/App/NavigationProvider/__tests__/navigationProvider.test.tsx

@@ -410,6 +410,62 @@ describe("<NavigationProvider />", () => {
       });
     });
 
+    describe("when backToTop is requested from a non-home tab", () => {
+      const listenRiver = {
+        id: "LISTEN",
+        home: false,
+        navigations: [],
+        ui_components: [],
+      };
+
+      beforeEach(() => {
+        wrapper = renderContextConsumer({
+          ...store,
+          rivers: { ...rivers, LISTEN: listenRiver },
+        });
+
+        act(() => {
+          getNavigatorValues(wrapper).navigator.replace(listenRiver);
+        });
+      });
+
+      it("returns to the tab root from the second level", () => {
+        act(() => {
+          getNavigatorValues(wrapper).navigator.push(rivers.A1234);
+        });
+
+        act(() => {
+          getNavigatorValues(wrapper).navigator.goBack(false, false, true);
+        });
+
+        const { navigator, state } = getNavigatorValues(wrapper);
+
+        expect(navigator.currentRoute).toEqual("/river/LISTEN");
+        expect(navigator.activeRiver).toEqual(listenRiver);
+        expect(state.stack.mainStack).toHaveLength(1);
+      });
+
+      it("returns to the tab root from the third level", () => {
+        act(() => {
+          getNavigatorValues(wrapper).navigator.push(rivers.A1234);
+        });
+
+        act(() => {
+          getNavigatorValues(wrapper).navigator.push(rivers.C0987);
+        });
+
+        act(() => {
+          getNavigatorValues(wrapper).navigator.goBack(false, false, true);
+        });
+
+        const { navigator, state } = getNavigatorValues(wrapper);
+
+        expect(navigator.currentRoute).toEqual("/river/LISTEN");
+        expect(navigator.activeRiver).toEqual(listenRiver);
+        expect(state.stack.mainStack).toHaveLength(1);
+      });
+    });
+
     describe("when there is a previous route and there are hooks", () => {
       beforeEach(() => {
         wrapper = renderContextConsumer();