@applicaster/zapp-react-native-ui-components 16.0.0-rc.5 → 16.0.0-rc.51

package/Components/ModalComponent/AudioPlayer/Components/index.ts

@@ -0,0 +1,9 @@
+export { AudioPlayerAction } from "./Action";
+
+export { AudioPlayerButton } from "./Button";
+
+export { AudioPlayerHeader } from "./Header";
+
+export { AudioPlayerTrackItem } from "./Item";
+
+export { AudioPlayerInput } from "./Input";

package/Components/ModalComponent/BottomSheetDragArea.tsx

@@ -0,0 +1,33 @@
+import React from "react";
+import { PanGestureHandler } from "react-native-gesture-handler";
+import { View } from "react-native";
+import { useBottomSheet } from "@applicaster/zapp-react-native-utils/bottomSheet";
+
+/**
+ * Turns its children into a drag zone for the enclosing DraggableBottomSheet:
+ * dragging here moves/dismisses the sheet (used for the modal header bar).
+ * Outside a sheet (no context) it renders children unchanged.
+ */
+export const BottomSheetDragArea = ({
+  children,
+}: {
+  children: React.ReactElement;
+}) => {
+  const sheet = useBottomSheet();
+
+  // Outside a sheet (no context) render children unchanged.
+  if (!sheet) return children;
+
+  return (
+    <PanGestureHandler
+      simultaneousHandlers={[sheet.masterDrawerRef]}
+      shouldCancelWhenOutside={false}
+      onGestureEvent={sheet.onDragGestureEvent}
+      onHandlerStateChange={sheet.onDragStateChange}
+    >
+      {/* Old-API PanGestureHandler needs a host-component child; children may
+          be a function component (e.g. ModalHeader), so wrap in a View. */}
+      <View>{children}</View>
+    </PanGestureHandler>
+  );
+};

package/Components/ModalComponent/BottomSheetModalContent.tsx

@@ -6,11 +6,11 @@ import { ItemProps } from "./Button/Item";
 import { ItemLabelProps } from "./Button/ItemLabel";
 import { getItemIconProps, getItemLabelProps, getItemProps } from "./utils";
 import { useTheme } from "@applicaster/zapp-react-native-utils/theme";
-
 import type { PluginConfiguration } from "./";
 
 import { ModalHeader as DefaultModalHeader } from "./Header";
 import { useSafeAreaInsets } from "react-native-safe-area-context";
+import { BottomSheetDragArea } from "./BottomSheetDragArea";
 
 type ModalComponentProps = {
   items: any[];
@@ -23,6 +23,12 @@ type ModalComponentProps = {
   maxHeight?: number;
   dismiss: () => void;
   headerComponent?: React.ComponentType;
+
+  scrollViewContent?: {
+    renderItem: (item: any, index: number) => React.ReactNode;
+    items: any[];
+  } | null;
+
   buttonComponent?: React.ComponentType;
   iconProps?: ItemIconProps | ((theme: PluginConfiguration) => ItemIconProps);
   itemProps?:
@@ -49,7 +55,9 @@ export function BottomSheetModalContent(props: ModalComponentProps) {
     dismiss,
     summary,
     title,
-    headerComponent: ModalHeader = DefaultModalHeader,
+    headerComponent = DefaultModalHeader,
+    scrollViewContent = null,
+
     buttonComponent: ButtonComponent = Button,
     getSelectedItemIcon = ({
       modal_bottom_sheet_item_selected_icon,
@@ -63,6 +71,8 @@ export function BottomSheetModalContent(props: ModalComponentProps) {
   const paddingTop = Number(theme.modal_bottom_sheet_padding_top);
   const paddingBottom = Number(theme.modal_bottom_sheet_padding_bottom);
 
+  const Header = headerComponent;
+
   useEffect(() => {
     if (currentRoute !== route.current) {
       props.dismiss();
@@ -98,35 +108,48 @@ export function BottomSheetModalContent(props: ModalComponentProps) {
         paddingTop: paddingTop,
       }}
     >
-      <ModalHeader
-        dismiss={dismiss}
-        configuration={theme}
-        summary={summary}
-        title={title}
-      />
+      {Header ? (
+        <BottomSheetDragArea>
+          <Header
+            dismiss={dismiss}
+            configuration={theme}
+            summary={summary}
+            title={title}
+          />
+        </BottomSheetDragArea>
+      ) : null}
       <ScrollView
+        overScrollMode="never"
+        bounces={false}
+        showsVerticalScrollIndicator={false}
         contentContainerStyle={{
           paddingBottom: paddingBottom + bottomInset,
         }}
       >
-        {items.map((item, index) =>
-          item ? (
-            <ButtonComponent
-              key={index}
-              configuration={theme}
-              selectedItem={current_selection}
-              item={item}
-              onPress={handlePress}
-              label={theme[item?.label] ?? item?.label}
-              iconBaseProps={iconBaseProps}
-              itemBaseProps={itemBaseProps}
-              labelBaseProps={labelBaseProps}
-              selectedItemIcon={getSelectedItemIcon(theme)}
-              defaultItemIcon={getDefaultItemIcon(theme)}
-              iconPlacement={iconPlacement}
-            />
-          ) : null
-        )}
+        {scrollViewContent
+          ? scrollViewContent.items.map((item, index) =>
+              scrollViewContent.renderItem(item, index)
+            )
+          : null}
+        {!scrollViewContent &&
+          items.map((item, index) =>
+            item ? (
+              <ButtonComponent
+                key={index}
+                configuration={theme}
+                selectedItem={current_selection}
+                item={item}
+                onPress={handlePress}
+                label={theme[item?.label] ?? item?.label}
+                iconBaseProps={iconBaseProps}
+                itemBaseProps={itemBaseProps}
+                labelBaseProps={labelBaseProps}
+                selectedItemIcon={getSelectedItemIcon(theme)}
+                defaultItemIcon={getDefaultItemIcon(theme)}
+                iconPlacement={iconPlacement}
+              />
+            ) : null
+          )}
       </ScrollView>
     </View>
   );

package/Components/ModalComponent/__tests__/BottomSheetDragArea.test.tsx

@@ -0,0 +1,74 @@
+import React from "react";
+import { Text } from "react-native";
+import { render, screen } from "@testing-library/react-native";
+import { BottomSheetDragArea } from "../BottomSheetDragArea";
+import { BottomSheetContext } from "@applicaster/zapp-react-native-utils/bottomSheet";
+
+// Reveal PanGestureHandler and capture its props.
+jest.mock("react-native-gesture-handler", () => {
+  const { View } = require("react-native");
+  const actual = jest.requireActual("react-native-gesture-handler");
+
+  return {
+    __esModule: true,
+    ...actual,
+    PanGestureHandler: ({
+      children,
+      onGestureEvent,
+      onHandlerStateChange,
+      simultaneousHandlers,
+    }: any) => (
+      <View
+        testID="drag-pan"
+        onGestureEvent={onGestureEvent}
+        onHandlerStateChange={onHandlerStateChange}
+        simultaneousHandlers={simultaneousHandlers}
+      >
+        {children}
+      </View>
+    ),
+  };
+});
+
+const makeValue = () => ({
+  scrollRef: React.createRef<any>(),
+  masterDrawerRef: React.createRef<any>(),
+  drawerRef: React.createRef<any>(),
+  onScroll: jest.fn(),
+  setBodyDragEnabled: jest.fn(),
+  onDragGestureEvent: jest.fn(),
+  onDragStateChange: jest.fn(),
+});
+
+describe("BottomSheetDragArea", () => {
+  it("wraps children in a sheet-wired PanGestureHandler when inside a sheet", () => {
+    const value = makeValue();
+
+    render(
+      <BottomSheetContext.Provider value={value}>
+        <BottomSheetDragArea>
+          <Text testID="child">hi</Text>
+        </BottomSheetDragArea>
+      </BottomSheetContext.Provider>
+    );
+
+    const pan = screen.getByTestId("drag-pan");
+    expect(pan.props.onGestureEvent).toBe(value.onDragGestureEvent);
+    expect(pan.props.onHandlerStateChange).toBe(value.onDragStateChange);
+
+    expect(pan.props.simultaneousHandlers).toEqual([value.masterDrawerRef]);
+
+    expect(screen.getByTestId("child")).toBeTruthy();
+  });
+
+  it("renders children bare when used outside a sheet", () => {
+    render(
+      <BottomSheetDragArea>
+        <Text testID="child">hi</Text>
+      </BottomSheetDragArea>
+    );
+
+    expect(screen.queryByTestId("drag-pan")).toBeNull();
+    expect(screen.getByTestId("child")).toBeTruthy();
+  });
+});

package/Components/OfflineHandler/__tests__/__snapshots__/index.test.tsx.snap

@@ -1,88 +1,7 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
-exports[`OfflineHandler renders 1`] = `
-<View
-  style={
-    {
-      "flex": 1,
-      "position": "relative",
-    }
-  }
->
-  <View
-    style={
-      {
-        "bottom": 0,
-        "left": 0,
-        "position": "absolute",
-        "right": 0,
-        "top": 0,
-      }
-    }
-  >
-    <View
-      accessibilityState={
-        {
-          "busy": undefined,
-          "checked": undefined,
-          "disabled": undefined,
-          "expanded": undefined,
-          "selected": undefined,
-        }
-      }
-      accessible={true}
-      collapsable={false}
-      focusable={true}
-      onClick={[Function]}
-      onResponderGrant={[Function]}
-      onResponderMove={[Function]}
-      onResponderRelease={[Function]}
-      onResponderTerminate={[Function]}
-      onResponderTerminationRequest={[Function]}
-      onStartShouldSetResponder={[Function]}
-      style={
-        {
-          "alignItems": "center",
-          "backgroundColor": undefined,
-          "flex": 1,
-          "height": 88,
-          "justifyContent": "center",
-          "left": 0,
-          "opacity": 0,
-          "position": "absolute",
-          "right": 0,
-          "top": 0,
-          "transform": [
-            {
-              "translateY": -88,
-            },
-          ],
-          "width": "100%",
-        }
-      }
-    >
-      <View
-        style={
-          {
-            "backgroundColor": undefined,
-            "height": 44,
-          }
-        }
-      />
-      <Text
-        style={
-          {
-            "color": undefined,
-            "fontFamily": undefined,
-            "fontSize": undefined,
-            "letterSpacing": undefined,
-            "lineHeight": undefined,
-          }
-        }
-      >
-        You are back online
-      </Text>
-    </View>
-  </View>
-</View>
+exports[`OfflineHandler renders its children without wrapping them in a notification view 1`] = `
+<Text>
+  child content
+</Text>
 `;

package/Components/OfflineHandler/__tests__/index.test.tsx

@@ -1,26 +1,26 @@
 import React from "react";
+import { Text } from "react-native";
 import { render } from "@testing-library/react-native";
+import { subscriberFor } from "@applicaster/zapp-react-native-utils/reactHooks/useSubscriberFor";
 
 jest.useFakeTimers({ legacyFakeTimers: true });
 
+// `isOnline` (@applicaster/quick-brick-core/App/NetworkStatusProvider/utils)
+// only treats connectionInfo as "ready" when it has NetInfoState-shaped
+// isConnected/isInternetReachable/details fields, so the mock has to mirror
+// that shape for online/offline to actually be distinguishable.
 let mockConnectionStatus = false;
-const mockPreviousValue = null;
 
 jest.mock("@applicaster/zapp-react-native-utils/reactHooks/connection", () => {
   return {
     ...jest.requireActual(
       "@applicaster/zapp-react-native-utils/reactHooks/connection"
     ),
-    useConnectionInfo: jest.fn(() => mockConnectionStatus),
-  };
-});
-
-jest.mock("@applicaster/zapp-react-native-utils/reactHooks/utils", () => {
-  return {
-    ...jest.requireActual(
-      "@applicaster/zapp-react-native-utils/reactHooks/utils"
-    ),
-    usePrevious: jest.fn(() => mockPreviousValue),
+    useConnectionInfo: jest.fn(() => ({
+      details: {},
+      isConnected: mockConnectionStatus,
+      isInternetReachable: mockConnectionStatus,
+    })),
   };
 });
 
@@ -54,21 +54,81 @@ jest.mock("react-native-safe-area-context", () => ({
 }));
 
 describe("OfflineHandler", () => {
-  const { OfflineHandler, NotificationView } = require("../");
+  const { OfflineHandler } = require("../");
+
+  beforeEach(() => {
+    mockConnectionStatus = false;
+  });
+
+  it("renders its children without wrapping them in a notification view", () => {
+    const { toJSON } = render(
+      <OfflineHandler>
+        <Text>child content</Text>
+      </OfflineHandler>
+    );
 
-  it("renders", () => {
-    const { toJSON } = render(<OfflineHandler />);
     expect(toJSON()).toMatchSnapshot();
   });
 
-  it("renders Notification mode if component was rendered while online", () => {
+  it("emits a showToast event on mount when the device starts offline", () => {
+    mockConnectionStatus = false;
+
+    const handleShowToast = jest.fn();
+    const unsubscribe = subscriberFor("showToast", handleShowToast);
+
+    render(<OfflineHandler />);
+
+    expect(handleShowToast).toHaveBeenCalledWith(
+      expect.objectContaining({
+        id: "offline-status",
+        message: "No internet connection",
+        timeout: 5000,
+      }),
+      // the shared event bus appends a dispose fn as the last handler arg
+      expect.any(Function)
+    );
+
+    unsubscribe();
+  });
+
+  it("does not emit a showToast event on mount when the device starts online", () => {
     mockConnectionStatus = true;
 
-    const { rerender, UNSAFE_getByType } = render(<OfflineHandler />);
+    const handleShowToast = jest.fn();
+    const unsubscribe = subscriberFor("showToast", handleShowToast);
+
+    render(<OfflineHandler />);
+
+    expect(handleShowToast).not.toHaveBeenCalled();
+
+    unsubscribe();
+  });
+
+  it("emits a showToast event when the device comes back online", () => {
+    mockConnectionStatus = false;
+
+    const handleShowToast = jest.fn();
+    const unsubscribe = subscriberFor("showToast", handleShowToast);
+
+    const { rerender } = render(<OfflineHandler />);
 
+    // ignore the offline toast emitted on mount; we only care about the
+    // offline -> online transition here
+    handleShowToast.mockClear();
+
+    mockConnectionStatus = true;
     rerender(<OfflineHandler />);
 
-    const notificationsView = UNSAFE_getByType(NotificationView);
-    expect(notificationsView).toBeDefined();
+    expect(handleShowToast).toHaveBeenCalledWith(
+      expect.objectContaining({
+        id: "offline-status",
+        message: "You are back online",
+        timeout: 2000,
+      }),
+      // the shared event bus appends a dispose fn as the last handler arg
+      expect.any(Function)
+    );
+
+    unsubscribe();
   });
 });

package/Components/OfflineHandler/hooks.ts

@@ -0,0 +1,123 @@
+import React, { useMemo } from "react";
+
+import {
+  isWeb,
+  platformSelect,
+} from "@applicaster/zapp-react-native-utils/reactUtils";
+import { sessionStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/SessionStorage";
+import { useSafeAreaInsets } from "react-native-safe-area-context";
+
+import { usePlugins } from "@applicaster/zapp-react-native-redux";
+import { textTransform } from "@applicaster/zapp-react-native-utils/cellUtils";
+import { findPluginByIdentifier } from "@applicaster/zapp-react-native-utils/pluginUtils";
+
+import { useTheme } from "@applicaster/zapp-react-native-utils/theme";
+
+const OFFLINE_EXPERIENCE = "offline-experience";
+
+const NETWORK_STATUS_LOCALIZATIONS_KEY = "network_status_localizations";
+
+const THEME_STORAGE_NAMESPACE = "quick-brick-theme";
+
+export const useNotificationHeight = () => {
+  const insets = useSafeAreaInsets();
+
+  const navBarHeight = platformSelect({ ios: 44, android: 56 });
+
+  const statusHeight = insets.top;
+  const notificationHeight = statusHeight + navBarHeight;
+
+  return { statusHeight, notificationHeight };
+};
+
+export function useNetworkStatusLocalizations() {
+  const [storedLocalizations, setStoredLocalizations] = React.useState<Record<
+    string,
+    string
+  > | null>(null);
+
+  React.useEffect(() => {
+    async function loadStoredLocalizations() {
+      try {
+        const stored = await sessionStorage.getItem(
+          NETWORK_STATUS_LOCALIZATIONS_KEY,
+          THEME_STORAGE_NAMESPACE
+        );
+
+        if (stored) {
+          setStoredLocalizations(stored);
+        }
+      } catch (error) {
+        console.error("Error loading network status localizations", error);
+      }
+    }
+
+    loadStoredLocalizations();
+  }, []);
+
+  return storedLocalizations;
+}
+
+export function useOfflineHandlerProps(online: boolean) {
+  const theme = useTheme<BaseThemePropertiesTV>();
+  const storedLocalizations = useNetworkStatusLocalizations();
+  const plugins = usePlugins();
+  const offlinePlugin = findPluginByIdentifier(OFFLINE_EXPERIENCE, plugins);
+  const { useOfflineExperienceConfiguration } = offlinePlugin?.module ?? {};
+
+  const {
+    configurationFields,
+    localizations,
+  }: {
+    configurationFields: OfflineExperiencePluginConfiguration;
+    localizations: OfflineExperienceLocalizations;
+  } = useOfflineExperienceConfiguration?.() ?? {};
+
+  let title, subtitle, style;
+
+  if (isWeb()) {
+    title = online
+      ? (theme?.online_notification_title ??
+        storedLocalizations?.online_notification_title)
+      : (theme?.offline_notification_title ??
+        storedLocalizations?.offline_notification_title);
+
+    subtitle = online
+      ? (theme?.online_notification_subtitle ??
+        storedLocalizations?.online_notification_subtitle)
+      : (theme?.offline_notification_subtitle ??
+        storedLocalizations?.offline_notification_subtitle);
+  } else {
+    title = textTransform(
+      configurationFields.offline_toast_message_text_transform,
+      online
+        ? localizations.online_toast_message
+        : localizations.offline_toast_message
+    );
+
+    style = {
+      color: online
+        ? configurationFields.offline_toast_message_online_font_color
+        : configurationFields.offline_toast_message_font_color,
+      backgroundColor: online
+        ? configurationFields.offline_toast_online_background_color
+        : configurationFields.offline_toast_offline_background_color,
+      fontFamily: platformSelect({
+        ios: configurationFields.offline_toast_message_ios_font_family,
+        android: configurationFields.offline_toast_message_android_font_family,
+      }),
+      fontSize: configurationFields.offline_toast_message_font_size,
+      lineHeight: configurationFields.offline_toast_message_line_height,
+      letterSpacing: platformSelect({
+        ios: configurationFields.offline_toast_message_letter_spacing_ios,
+        android:
+          configurationFields.offline_toast_message_letter_spacing_android,
+      }),
+    };
+  }
+
+  return useMemo(
+    () => ({ message: title, extraMessage: subtitle, style }),
+    [title, subtitle, style]
+  );
+}