@applicaster/zapp-react-native-ui-components 16.0.0-rc.8 → 16.0.0-rc.80

package/Components/ModalComponent/utils.ts

@@ -1,4 +1,8 @@
 import { platformSelect } from "@applicaster/zapp-react-native-utils/reactUtils";
+import {
+  toNumberWithDefault,
+  toNumberWithDefaultZero,
+} from "@applicaster/zapp-react-native-utils/numberUtils";
 import { PluginConfiguration } from "./";
 import { ItemIconProps } from "./Button/ItemIcon";
 import { ItemLabelProps } from "./Button/ItemLabel";
@@ -6,7 +10,8 @@ import { ItemProps } from "./Button/Item";
 
 export function defaultItemProps(
   config: PluginConfiguration,
-  maxWidth: number
+  maxWidth: number,
+  blockItemStyle?: Record<string, any>
 ): ItemProps {
   const {
     modal_bottom_sheet_item_background_color,
@@ -24,19 +29,31 @@ export function defaultItemProps(
     modal_bottom_sheet_item_padding_top,
   } = config;
 
+  const bgDefault = blockItemStyle?.background?.default;
+
   return {
-    backgroundColor: modal_bottom_sheet_item_background_color,
+    backgroundColor:
+      bgDefault?.backgroundColor || modal_bottom_sheet_item_background_color,
     focusedBackgroundColor: modal_bottom_sheet_item_focus_background_color,
     selectedBackgroundColor: modal_bottom_sheet_item_selected_background_color,
     focusedSelectedBackgroundColor:
       modal_bottom_sheet_item_focused_selected_background_color,
-    borderRadius: modal_bottom_sheet_item_corner_radius,
+    borderRadius: toNumberWithDefault(
+      modal_bottom_sheet_item_corner_radius,
+      bgDefault?.borderRadius
+    ),
     marginBottom: modal_bottom_sheet_item_margin_bottom,
     marginTop: modal_bottom_sheet_item_margin_top,
     marginLeft: modal_bottom_sheet_item_margin_left,
     marginRight: modal_bottom_sheet_item_margin_right,
-    paddingTop: modal_bottom_sheet_item_padding_top,
-    paddingBottom: modal_bottom_sheet_item_padding_bottom,
+    paddingTop: toNumberWithDefault(
+      modal_bottom_sheet_item_padding_top,
+      bgDefault?.paddingTop
+    ),
+    paddingBottom: toNumberWithDefault(
+      modal_bottom_sheet_item_padding_bottom,
+      bgDefault?.paddingBottom
+    ),
     paddingRight: modal_bottom_sheet_item_padding_right,
     paddingLeft: modal_bottom_sheet_item_padding_left,
     maxWidth,
@@ -45,7 +62,8 @@ export function defaultItemProps(
 
 export function defaultItemLabelProps(
   config: PluginConfiguration,
-  sheetWidth: number
+  sheetWidth: number,
+  blockItemStyle?: Record<string, any>
 ): ItemLabelProps {
   const {
     modal_bottom_sheet_item_label_android_letter_spacing,
@@ -72,15 +90,48 @@ export function defaultItemLabelProps(
     modal_bottom_sheet_item_padding_right,
   } = config;
 
-  const maxWidth =
+  const iconWidth = toNumberWithDefaultZero(modal_bottom_sheet_item_icon_width);
+
+  const iconMarginLeft = toNumberWithDefaultZero(
+    modal_bottom_sheet_item_icon_margin_left
+  );
+
+  const iconMarginRight = toNumberWithDefaultZero(
+    modal_bottom_sheet_item_icon_margin_right
+  );
+
+  const itemMarginLeft = toNumberWithDefaultZero(
+    modal_bottom_sheet_item_margin_left
+  );
+
+  const itemMarginRight = toNumberWithDefaultZero(
+    modal_bottom_sheet_item_margin_right
+  );
+
+  const itemPaddingLeft = toNumberWithDefaultZero(
+    modal_bottom_sheet_item_padding_left
+  );
+
+  const itemPaddingRight = toNumberWithDefaultZero(
+    modal_bottom_sheet_item_padding_right
+  );
+
+  const calculatedMaxWidth =
     sheetWidth -
-    (modal_bottom_sheet_item_icon_width +
-      modal_bottom_sheet_item_icon_margin_left +
-      modal_bottom_sheet_item_icon_margin_right +
-      modal_bottom_sheet_item_margin_left +
-      modal_bottom_sheet_item_margin_right +
-      modal_bottom_sheet_item_padding_left +
-      modal_bottom_sheet_item_padding_right);
+    (iconWidth +
+      iconMarginLeft +
+      iconMarginRight +
+      itemMarginLeft +
+      itemMarginRight +
+      itemPaddingLeft +
+      itemPaddingRight);
+
+  const maxWidth =
+    Number.isNaN(calculatedMaxWidth) || calculatedMaxWidth <= 0
+      ? sheetWidth
+      : calculatedMaxWidth;
+
+  const label1Default = blockItemStyle?.textLabel1?.default;
 
   return {
     fontFamily: platformSelect({
@@ -91,8 +142,11 @@ export function defaultItemLabelProps(
       ios: modal_bottom_sheet_item_label_ios_letter_spacing,
       android: modal_bottom_sheet_item_label_android_letter_spacing,
     }),
-    fontSize: modal_bottom_sheet_item_label_font_size,
-    color: modal_bottom_sheet_item_label_font_color,
+    fontSize: toNumberWithDefault(
+      modal_bottom_sheet_item_label_font_size,
+      label1Default?.fontSize
+    ),
+    color: label1Default?.fontColor || modal_bottom_sheet_item_label_font_color,
     focusColor: modal_bottom_sheet_item_label_focus_font_color,
     hoverSelectedColor: modal_bottom_sheet_item_label_hover_selected_font_color,
     selectedColor: modal_bottom_sheet_item_label_selected_font_color,
@@ -146,7 +200,8 @@ export function getItemLabelProps(
   width: number,
   labelProps?:
     | ((theme: PluginConfiguration, width: number) => ItemLabelProps)
-    | ItemLabelProps
+    | ItemLabelProps,
+  blockItemStyle?: Record<string, any>
 ) {
   if (labelProps) {
     return typeof labelProps === "function"
@@ -154,7 +209,7 @@ export function getItemLabelProps(
       : labelProps;
   }
 
-  return defaultItemLabelProps(theme, width);
+  return defaultItemLabelProps(theme, width, blockItemStyle);
 }
 
 export function getItemProps(
@@ -162,7 +217,8 @@ export function getItemProps(
   width: number,
   itemProps?:
     | ((theme: PluginConfiguration, width: number) => ItemProps)
-    | ItemProps
+    | ItemProps,
+  blockItemStyle?: Record<string, any>
 ) {
   if (itemProps) {
     return typeof itemProps === "function"
@@ -170,5 +226,5 @@ export function getItemProps(
       : itemProps;
   }
 
-  return defaultItemProps(theme, width);
+  return defaultItemProps(theme, width, blockItemStyle);
 }

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]
+  );
+}

package/Components/OfflineHandler/index.tsx

@@ -1,105 +1,83 @@
-import React, { useCallback, useEffect, useRef, useState } from "react";
-import { View, StyleSheet } from "react-native";
-import { NotificationView as NotificationViewNative } from "./NotificationView/NotificationView";
-import { NotificationView as NotificationViewSamsung } from "./NotificationView/NotificationView.samsung";
-import { NotificationView as NotificationViewLG } from "./NotificationView/NotificationView.lg";
-
+import React, { useCallback, useEffect } from "react";
 import { useConnectionInfo } from "@applicaster/zapp-react-native-utils/reactHooks/connection";
 import { usePrevious } from "@applicaster/zapp-react-native-utils/reactHooks/utils";
-import { platformSelect } from "@applicaster/zapp-react-native-utils/reactUtils";
+import { useSubscriberFor } from "@applicaster/zapp-react-native-utils/reactHooks/useSubscriberFor";
 
+import { useOfflineHandlerProps } from "./hooks";
 import { componentsLogger } from "../../Helpers/logger";
 import { parseConnectionInfo } from "./utils";
 
 const logger = componentsLogger.addSubsystem("OfflineHandler");
 
+// mirrors NOTIFICATION_TOAST_EVENTS.SHOW_TOAST in
+// @applicaster/quick-brick-core/App/NotificationToastRenderer/NotificationToastManager
+// (kept as a literal here since this package must not depend on quick-brick-core)
+const SHOW_TOAST_EVENT = "showToast";
+const OFFLINE_STATUS_TOAST_ID = "offline-status";
+
 type Props = {
   children?: React.ReactElement<any>;
 };
 
-const styles = StyleSheet.create({
-  container: {
-    flex: 1,
-    position: "relative",
-  },
-});
-
 const timers = {
   goingOffline: 5000,
   goingOnline: 2000,
 };
 
-export const NotificationView = platformSelect({
-  samsung_tv: NotificationViewSamsung,
-  lg_tv: NotificationViewLG,
-  default: NotificationViewNative,
-});
-
 export const OfflineHandler = ({ children }: Props) => {
   const connectionInfo = useConnectionInfo(false);
-  const { online, deviceOnline } = parseConnectionInfo(connectionInfo);
+  const { online } = parseConnectionInfo(connectionInfo);
+  const prevOnline = usePrevious(online);
 
-  const [hidden, setHidden] = useState<boolean>(true);
-  const previousOnline: boolean = usePrevious(online);
-  const timer = useRef<NodeJS.Timeout | null>(null);
-  const initialRender = useRef(false);
+  const emitShowToast = useSubscriberFor(SHOW_TOAST_EVENT);
 
-  const dismiss = useCallback(() => {
-    setHidden(true);
+  const { message, extraMessage, style } = useOfflineHandlerProps(online);
 
-    if (timer.current) {
-      clearTimeout(timer.current);
-      timer.current = null;
-    }
-  }, []);
+  const showOnlineToast = useCallback(() => {
+    logger.log("Device is back online, emit toast");
 
-  const setTimer = useCallback((cb, duration) => {
-    if (timer.current) {
-      clearTimeout(timer.current);
-    }
+    emitShowToast({
+      id: OFFLINE_STATUS_TOAST_ID,
+      message,
+      extraMessage,
+      style,
+      timeout: timers.goingOnline,
+    });
+  }, [emitShowToast, message, extraMessage, style]);
+
+  const showOfflineToast = useCallback(() => {
+    logger.log("Device went offline, emit toast");
 
-    timer.current = setTimeout(cb, duration);
-  }, []);
+    emitShowToast({
+      id: OFFLINE_STATUS_TOAST_ID,
+      message,
+      extraMessage,
+      style,
+      timeout: timers.goingOffline,
+    });
+  }, [emitShowToast, message, extraMessage, style]);
 
   useEffect(() => {
-    if (initialRender.current) {
-      const wentOffline = previousOnline && online === false;
-      const wentOnline = !previousOnline && online;
-      const renderedOffline = !online && previousOnline === null;
-
-      if (!deviceOnline || wentOffline || renderedOffline) {
-        logger.log("Device went offline");
-        setTimer(() => setHidden(true), timers.goingOffline);
-        setHidden(false);
+    // On mount there is no previous state yet: only surface the offline toast
+    // for a device that starts offline. Don't announce "back online" for a
+    // device that was online to begin with.
+    if (prevOnline === undefined) {
+      if (!online) {
+        showOfflineToast();
       }
 
-      if (wentOnline) {
-        logger.log("Device is back online");
-        setHidden(false);
-        setTimer(() => setHidden(true), timers.goingOnline);
-      }
-    } else {
-      initialRender.current = true;
+      return;
     }
 
-    return () => {
-      if (timer.current) {
-        clearTimeout(timer.current);
-        timer.current = null;
+    // On subsequent renders, only emit a toast when the online/offline state changes.
+    if (prevOnline !== online) {
+      if (!online) {
+        showOfflineToast();
+      } else {
+        showOnlineToast();
       }
-    };
-  }, [connectionInfo]);
-
-  return (
-    <View style={styles.container}>
-      <NotificationView
-        hidden={hidden}
-        online={online}
-        previousOnline={previousOnline}
-        dismiss={dismiss}
-      >
-        {children}
-      </NotificationView>
-    </View>
-  );
+    }
+  }, [online, prevOnline, showOfflineToast, showOnlineToast]);
+
+  return children;
 };

package/Components/OfflineHandler/utils/index.ts

@@ -1,9 +1,8 @@
 import * as R from "ramda";
-
 import { NetInfoState } from "@react-native-community/netinfo";
 import { platformSelect } from "@applicaster/zapp-react-native-utils/reactUtils";
 import { isOnline as isOnlineUtils } from "@applicaster/quick-brick-core/App/NetworkStatusProvider/utils";
-import { useSafeAreaInsets } from "react-native-safe-area-context";
+
 import { Platform } from "react-native";
 
 type ConnectionInfo = NetInfoState & { deviceStatus: NetStatus };
@@ -51,14 +50,3 @@ export const parseConnectionInfo: typeof parseConnectionInfoForDefault =
     samsung_tv: parseConnectionInfoForSamsung,
     default: parseConnectionInfoForDefault,
   });
-
-export const useNotificationHeight = () => {
-  const insets = useSafeAreaInsets();
-
-  const navBarHeight = platformSelect({ ios: 44, android: 56 });
-
-  const statusHeight = insets.top;
-  const notificationHeight = statusHeight + navBarHeight;
-
-  return { statusHeight, notificationHeight };
-};