@applicaster/zapp-react-native-ui-components 13.0.0-alpha.6523249552 → 13.0.0-alpha.6651373134

package/Components/Focusable/FocusableTvOS.tsx

@@ -9,7 +9,7 @@ import {
   focusManager,
   forceFocusableFocus,
 } from "@applicaster/zapp-react-native-utils/appUtils/focusManager/index.ios";
-import { findNodeHandle } from "react-native";
+import { findNodeHandle, ViewStyle } from "react-native";
 
 function noop() {}
 
@@ -35,6 +35,10 @@ type Props = {
   forceFocus?: boolean;
   initialFocus?: boolean;
   onLayout?: (e: any) => void;
+  willReceiveFocus: () => void;
+  hasReceivedFocus: () => void;
+  offsetUpdater: (arg1: string, arg2: number) => number;
+  style: ViewStyle;
 };
 
 export class Focusable extends BaseFocusable<Props> {

package/Components/Focusable/index.android.tsx

@@ -33,6 +33,8 @@ type Props = {
   onLongPress?: (ref: FocusManager.FocusableRef) => void;
   onRegister?: () => void;
   isFocusableCell?: boolean;
+  /** only for FocusableScrollView */
+  onSetIsFocusable?: (isFocusable: boolean) => void;
 } & ParentFocus;
 
 export const FocusableContext = React.createContext<
@@ -67,6 +69,7 @@ function FocusableComponent(props: Props, forwardedRef) {
     onLongPress,
     onRegister = noop,
     isFocusableCell = true,
+    onSetIsFocusable,
   } = props;
 
   const isRTL = useIsRTL();
@@ -137,9 +140,13 @@ function FocusableComponent(props: Props, forwardedRef) {
     [onBlur]
   );
 
-  const setIsFocusable = React.useCallback((blockFocus) => {
-    setDisableFocus(!blockFocus);
-  }, []);
+  const setIsFocusable = React.useCallback(
+    (blockFocus) => {
+      onSetIsFocusable?.(blockFocus);
+      setDisableFocus(!blockFocus);
+    },
+    [onSetIsFocusable]
+  );
 
   const parentFocus = React.useMemo(
     () => ({

package/Components/FocusableCell/index.tsx

@@ -23,7 +23,7 @@ export function FocusableCell(props: Props) {
     behavior,
   } = props;
 
-  const state = useCellState({ id: item.id, behavior, focused });
+  const state = useCellState({ item, behavior, focused });
 
   React.useEffect(() => {
     if (focused && scrollTo && !isAndroid) {

package/Components/FocusableGroup/FocusableTvOS.tsx

@@ -1,17 +1,30 @@
 import * as React from "react";
 import { FocusableGroupNative } from "@applicaster/zapp-react-native-ui-components/Components/NativeFocusables";
 import { BaseFocusable } from "@applicaster/zapp-react-native-ui-components/Components/BaseFocusable";
-
-function noop() {}
+import { createLogger } from "@applicaster/zapp-react-native-utils/logger";
+
+const { log_verbose } = createLogger({
+  subsystem: "General",
+  category: "FocusableGroup",
+});
+
+type FocusableGroupNativeEvent = {
+  nativeEvent: {
+    focusHeading: FocusManager.Direction;
+    groupId: string;
+    isActive: boolean;
+    isFocusDisabled: boolean;
+    isFocusingByUser: boolean;
+    itemId: string;
+    target: number;
+  };
+};
 
 type Props = {
   id: string;
   children: (arg1: boolean) => React.ComponentType<any>;
-  onWillUpdateFocus: (nativeEvent: any) => void;
-  onDidUpdateFocus: (nativeEvent: any) => void;
   isFocusDisabled: boolean;
-  initialItemId: string;
-  resetFocusToInitialValue: boolean;
+  isWithMemory: boolean;
   focusGroupRef: React.Component;
   shouldUsePreferredFocus: boolean;
   groupId: string;
@@ -21,86 +34,26 @@ type Props = {
 };
 
 export class FocusableGroup extends BaseFocusable<Props> {
-  focusableGroupNativeRef: React.Component | null;
-  constructor(props) {
-    super(props);
-    this.focusableGroupNativeRef = null;
-
-    this.state = {
-      isActive: false,
-    };
-
-    this.onWillUpdateFocus = this.onWillUpdateFocus.bind(this);
-    this.onDidUpdateFocus = this.onDidUpdateFocus.bind(this);
-    this.isGroup = true;
-
-    this.shouldUsePreferredFocus = this.shouldUsePreferredFocus.bind(this);
-    this.measureView = this.measureView.bind(this);
-  }
-
-  connectedScreenId() {
-    const {
-      screenData: { screenId, parentScreenId },
-    } = this.props;
-
-    if (screenId) {
-      return null;
-    }
-
-    return parentScreenId ? `${parentScreenId}-${screenId}` : screenId;
-  }
-
-  /**
-   * tells whether the group should give focus to a preferred item when it gains focus from another
-   * group
-   * @returns {boolean}
-   */
-  shouldUsePreferredFocus() {
-    return this.props.shouldUsePreferredFocus || false;
-  }
-
-  /**
-   * indicates whether the underlying component should claim preferred focus
-   * when navigating into the group of this item
-   * @returns {boolean}
-   */
-  isPreferredFocus() {
-    return this.props.preferredFocus || false;
-  }
-
-  onWillUpdateFocus({ nativeEvent }) {
-    const { isActive } = nativeEvent;
-    this.setState({ isActive });
-    const { onWillUpdateFocus = noop } = this.props;
-    onWillUpdateFocus(nativeEvent);
-  }
-
-  onDidUpdateFocus({ nativeEvent }) {
-    const { onDidUpdateFocus = noop } = this.props;
-    onDidUpdateFocus(nativeEvent);
-  }
-
-  setFocusDisabled(isFocusDisabled) {
-    if (this.ref) {
-      this.ref.current.setNativeProps({
-        isFocusDisabled,
-      });
-    }
-  }
-
   render() {
     const {
       children,
       id,
       isFocusDisabled,
-      initialItemId,
-      resetFocusToInitialValue,
-      style,
+      isWithMemory,
+      style = {},
       groupId,
       ...otherProps
     } = this.props;
 
-    const focusableStyles = style || {};
+    const onGroupFocus = ({ nativeEvent }: FocusableGroupNativeEvent) => {
+      log_verbose("FOCUSABLE_GROUP: onGroupFocus", { nativeEvent });
+      this.onFocus(this.ref, nativeEvent.focusHeading);
+    };
+
+    const onGroupBlur = ({ nativeEvent }: FocusableGroupNativeEvent) => {
+      log_verbose("FOCUSABLE_GROUP: onGroupBlur", { nativeEvent });
+      this.onBlur(this.ref, nativeEvent.focusHeading);
+    };
 
     return (
       <FocusableGroupNative
@@ -108,16 +61,11 @@ export class FocusableGroup extends BaseFocusable<Props> {
         itemId={id}
         ref={this.ref}
         isFocusDisabled={isFocusDisabled}
-        initialItemId={initialItemId}
-        resetFocusToInitialValue={resetFocusToInitialValue}
-        onLayout={this.measureView}
-        onViewFocus={this.onFocus}
-        onViewPress={this.onPress}
-        onViewBlur={this.onBlur}
-        style={focusableStyles}
+        isWithMemory={isWithMemory}
+        onGroupFocus={onGroupFocus}
+        onGroupBlur={onGroupBlur}
+        style={style}
         {...otherProps}
-        onWillUpdateFocus={this.onWillUpdateFocus}
-        onDidUpdateFocus={this.onDidUpdateFocus}
       >
         {children}
       </FocusableGroupNative>

package/Components/FocusableGroup/index.tsx

@@ -16,12 +16,9 @@ type Props = {
   prioritiseFocusOn?: number;
   groupId?: string;
   hasTVPreferredFocus?: boolean;
-  resetFocusToInitialValue?: boolean;
   onFocus?: () => void;
   onBlur?: () => void;
-  onWillUpdateFocus?: (event?: any) => void;
   willReceiveFocus?: (event?: any) => void;
-  onDidUpdateFocus?: (event?: any) => void;
   hasLostFocus?: any;
   nextFocusUp?: any;
   nextFocusDown?: any;

package/Components/FocusableList/index.tsx

@@ -15,6 +15,7 @@ import { noop } from "@applicaster/zapp-react-native-utils/functionUtils";
 
 import { useParentFocus, useCheckItemIdsForUnique } from "./hooks";
 import { FocusableListItemWrapper } from "./FocusableListItemWrapper";
+import { FocusableScrollView } from "../FocusableScrollView";
 
 const mapIndexed = R.addIndex(R.map);
 
@@ -54,6 +55,7 @@ export type Props<ItemT> = FlatListProps<ItemT> & {
   disableNextFocusUp?: boolean;
   disableNextFocusLeft?: boolean;
   disableNextFocusRight?: boolean;
+  useScrollView?: boolean;
 } & ParentFocus;
 
 function FocusableListComponent<ItemT>(props: Props<ItemT>, ref) {
@@ -88,6 +90,7 @@ function FocusableListComponent<ItemT>(props: Props<ItemT>, ref) {
     data = [],
     // eslint-disable-next-line unused-imports/no-unused-vars
     omitPropsPropagation = [],
+    useScrollView = false,
   } = props;
 
   useCheckItemIdsForUnique({ componentId: props.id, items: data });
@@ -273,6 +276,7 @@ function FocusableListComponent<ItemT>(props: Props<ItemT>, ref) {
         "initialFocusDirection",
         "withStateMemory",
         "useSequentialLoading",
+        "useScrollView",
         ...omitPropsPropagation,
       ],
       R.__
@@ -295,15 +299,28 @@ function FocusableListComponent<ItemT>(props: Props<ItemT>, ref) {
   return (
     // @ts-ignore
     <ChildrenFocusDeactivatorView flex={1}>
-      <FlatList
-        focusable={false}
-        scrollEnabled={false}
-        ref={ref}
-        {...getFlatListProps(props)}
-        renderItem={renderItem}
-        onEndReached={onEndReached}
-        initialNumToRender={initialNumToRender}
-      />
+      {useScrollView ? (
+        <FocusableScrollView
+          ref={ref}
+          {...getFlatListProps(props)}
+          onEndReached={onEndReached}
+          initialNumToRender={initialNumToRender}
+          renderItem={renderItem}
+          focused={focused}
+          data={data}
+        />
+      ) : (
+        <FlatList
+          testID="focusable-list-flat-list"
+          focusable={false}
+          scrollEnabled={false}
+          ref={ref}
+          {...getFlatListProps(props)}
+          renderItem={renderItem}
+          onEndReached={onEndReached}
+          initialNumToRender={initialNumToRender}
+        />
+      )}
     </ChildrenFocusDeactivatorView>
   );
 }

package/Components/FocusableScrollView/index.tsx

@@ -11,6 +11,13 @@ import {
   useInitialFocus,
 } from "@applicaster/zapp-react-native-utils/focusManager";
 
+export type FocusableScrollViewRenderItem = (info: {
+  item: ZappUIComponent;
+  index: number;
+  focused: boolean;
+  parentFocus: ParentFocus;
+}) => React.ReactElement;
+
 export type Props = ScrollViewProps & {
   id?: number | string;
   horizontal?: boolean;
@@ -32,17 +39,27 @@ export type Props = ScrollViewProps & {
   initialFocusDirection?: FocusManager.Android.FocusNavigationDirections;
   onAllComponentsLoaded?: () => void;
   omitPropsPropagation?: Array<keyof FlatListProps<any>>;
-  renderItem: (info: {
-    item: ZappUIComponent;
-    index: number;
-    focused: boolean;
-    parentFocus: ParentFocus;
-  }) => React.ReactElement;
+  renderItem: FocusableScrollViewRenderItem;
 } & ParentFocus;
 
 type State = boolean[];
 type Action = { index?: number; isFocusable: boolean; type?: string };
 
+const unwrapArray = (maybeArray) =>
+  Array.isArray(maybeArray) ? maybeArray[0] : maybeArray;
+
+const getEntry = <T extends unknown>(data: T | T[], index: unknown): T => {
+  let entry;
+
+  if (R.isNil(index)) {
+    entry = unwrapArray(data);
+  } else if (typeof index === "number") {
+    entry = unwrapArray(data[index]);
+  }
+
+  return entry;
+};
+
 const focusableStateReducer = (
   state: State,
   { index = null, isFocusable, type = null }: Action
@@ -73,7 +90,7 @@ const extendScrollViewRef = (_ref, childCompsMeasurementsMap) => {
   };
 
   _ref.scrollToIndex = (params) => {
-    const { index, viewOffset } = params;
+    const { index, viewOffset = 0 } = params;
 
     const itemByIndex = R.find(R.propEq("index", index))(
       R.values(childCompsMeasurementsMap)
@@ -129,8 +146,11 @@ function FocusableScrollViewComponent(props: Props, ref) {
   );
 
   const getFocusableEntryId = React.useCallback(
-    (_entry: ZappEntry, index?: number) => {
-      const entry = R.isNil(index) ? _entry : data[index];
+    (_entry: ZappEntry | null, index?: number) => {
+      const entry: { id?: string } = getEntry(
+        R.isNil(index) ? _entry : data,
+        index
+      );
 
       return entry ? `${props.id}--${entry?.id}` : undefined;
     },
@@ -273,16 +293,25 @@ function FocusableScrollViewComponent(props: Props, ref) {
   const renderItem = React.useCallback(
     (item, index) => {
       const renderArgs = { item, index };
-      const id = `${props.id}--${renderArgs?.item?.id}`;
-      const nextFocus = getNextFocus(renderArgs?.index);
+
+      const id = getFocusableEntryId(
+        Array.isArray(item) ? item[0] : item,
+        index
+      );
+
+      const nextFocus = getNextFocus(index);
 
       const onItemLayout = (event) => {
-        childCompsMeasurementsMap.current[item.id] = {
+        childCompsMeasurementsMap.current[
+          Array.isArray(item) ? index : item.id
+        ] = {
           index,
           layout: event.nativeEvent.layout,
         };
       };
 
+      const onSetIsFocusable = setIsFocusable(renderArgs.index);
+
       return (
         <View key={id} onLayout={onItemLayout}>
           <Focusable
@@ -305,6 +334,7 @@ function FocusableScrollViewComponent(props: Props, ref) {
             id={id}
             disableFocus={shouldDisableFocus(renderArgs?.index)}
             blockFocus={!isRendered(renderArgs?.index)}
+            onSetIsFocusable={onSetIsFocusable}
             {...focusableItemProps}
           >
             {(focused, parentFocus, parentRef) => (
@@ -319,7 +349,7 @@ function FocusableScrollViewComponent(props: Props, ref) {
                 isReadyToRender={isReadyToRender}
                 onLoadFinished={onLoadFinished(renderArgs.index)}
                 onLoadFailed={onLoadFailed(renderArgs.index)}
-                setIsFocusable={setIsFocusable(renderArgs.index)}
+                setIsFocusable={onSetIsFocusable}
               />
             )}
           </Focusable>

package/Components/HandlePlayable/HandlePlayable.tsx

@@ -1,14 +1,14 @@
 import * as React from "react";
 import * as R from "ramda";
-import { ViewStyle } from "react-native";
 import {
   findPluginByType,
   findPluginByIdentifier,
 } from "@applicaster/zapp-react-native-utils/pluginUtils";
-import { useDimensions } from "@applicaster/zapp-react-native-utils/reactHooks/layout";
 import { usePickFromState } from "@applicaster/zapp-react-native-redux/hooks";
-import { useNavigation } from "@applicaster/zapp-react-native-utils/reactHooks";
-import { platformSelect } from "@applicaster/zapp-react-native-utils/reactUtils";
+import {
+  useDimensions,
+  useNavigation,
+} from "@applicaster/zapp-react-native-utils/reactHooks";
 
 import { BufferAnimation } from "../PlayerContainer/BufferAnimation";
 import { PlayerContainer } from "../PlayerContainer";
@@ -78,12 +78,6 @@ const getPlayer = (
   return getPlayerWithModuleProperties(PlayerModule);
 };
 
-const dimensionsContext: "window" | "screen" = platformSelect({
-  android_tv: "window",
-  amazon: "window",
-  default: "screen",
-});
-
 type PlayableComponent = {
   Component: React.ComponentType<any>;
 };
@@ -91,16 +85,11 @@ type PlayableComponent = {
 export function HandlePlayable({
   item,
   isModal,
-  modalHeight,
-  modalWidth,
   mode,
   groupId,
 }: Props): React.ReactElement | null {
   const state = usePickFromState();
 
-  const { width: screenWidth, height: screenHeight } =
-    useDimensions(dimensionsContext);
-
   const { closeVideoModal } = useNavigation();
 
   const [Player, playerModuleProperties] = getPlayer(item, state);
@@ -118,9 +107,7 @@ export function HandlePlayable({
     if (!isModal) {
       closeVideoModal();
     }
-  }, []);
 
-  React.useEffect(() => {
     const castStateHandler = async () => {
       const castState = await CastPlugin?.getCastState();
       setCasting(castState === "Connected");
@@ -142,23 +129,23 @@ export function HandlePlayable({
   }, []);
 
   React.useEffect(() => {
-    if (casting) {
-      setPlayable({ Component: CastPlugin?.CastHandler });
-    } else {
-      setPlayable({ Component: PlayerContainer });
-    }
+    setPlayable({
+      Component: casting ? CastPlugin?.CastHandler : PlayerContainer,
+    });
   }, [casting]);
 
-  const Component = playable?.Component;
+  const { width: screenWidth, height: screenHeight } = useDimensions("window");
 
   const style = React.useMemo(
     () => ({
-      width: isModal ? modalWidth : mode === "PIP" ? "100%" : screenWidth,
-      height: isModal ? modalHeight : mode === "PIP" ? "100%" : screenHeight,
+      width: isModal ? "100%" : mode === "PIP" ? "100%" : screenWidth,
+      height: isModal ? "100%" : mode === "PIP" ? "100%" : screenHeight,
     }),
-    [screenWidth, screenHeight, modalHeight, modalWidth, isModal, mode]
+    [screenWidth, screenHeight, isModal, mode]
   );
 
+  const Component = playable?.Component;
+
   if (Component) {
     return (
       <Component
@@ -174,5 +161,5 @@ export function HandlePlayable({
     );
   }
 
-  return !isModal ? <BufferAnimation videoStyle={style as ViewStyle} /> : null;
+  return !isModal ? <BufferAnimation videoStyle={style} /> : null;
 }

package/Components/Layout/TV/NavBarContainer.tsx

@@ -1,9 +1,5 @@
 import * as React from "react";
-import { View, StyleSheet } from "react-native";
-import { ScreenLayoutContext } from "@applicaster/zapp-react-native-ui-components/Contexts/ScreenLayoutContext";
-import { ifEmptyUseFallback } from "@applicaster/zapp-react-native-utils/cellUtils";
-import { useCurrentScreenData } from "@applicaster/zapp-react-native-utils/reactHooks/screen";
-import { useScreenConfiguration } from "../../River/useScreenConfiguration";
+import { StyleSheet, View } from "react-native";
 
 type Props = {
   children: React.ReactNode;
@@ -12,33 +8,33 @@ type Props = {
 };
 
 const styles = StyleSheet.create({
-  container: { position: "absolute", top: 0, zIndex: 10, width: 1920 },
+  container: {
+    position: "absolute",
+    top: 0,
+    zIndex: 10,
+    flex: 1,
+    width: "100%",
+  },
+  themeStyles: {
+    // limits the height of the focusable container of the TopMenuBarTV component
+    // to prevent it from being overlapped by the screen content,
+    // as it makes TopMenuBarTV unfocusable on tvOS
+    maxHeight: 1,
+  },
 });
 
 export const NavBarContainer = ({ children, isVisible, onReady }: Props) => {
-  const screenLayout = React.useContext(ScreenLayoutContext);
-  const screenMarginTop = screenLayout?.screenMarginTop || 0;
-  const screen = useCurrentScreenData();
-  const screenConfig = useScreenConfiguration(screen?.id);
-
-  const themeStyles = React.useMemo(
-    () => ({
-      // limits the height of the focusable container of the TopMenuBarTV component
-      // to prevent it from being overlapped by the screen content,
-      // as it makes TopMenuBarTV unfocusable on tvOS
-      maxHeight: ifEmptyUseFallback(screenConfig?.marginTop, screenMarginTop),
-    }),
-    [screenLayout, screenConfig]
-  );
-
   React.useEffect(() => {
     setTimeout(() => {
       onReady?.(true);
     }, 0);
-  }, []);
+  }, [onReady]);
 
   return isVisible ? (
-    <View testID="nav-bar-container" style={[styles.container, themeStyles]}>
+    <View
+      testID="nav-bar-container"
+      style={[styles.container, styles.themeStyles]}
+    >
       {children}
     </View>
   ) : null;

package/Components/Layout/TV/ScreenContainer.tsx

@@ -55,8 +55,11 @@ export const ScreenContainer = React.memo(function ScreenContainer({
   ComponentsExtraProps,
   NavBar,
 }: Props) {
-  const { screenMarginBottom } = React.useContext(ScreenLayoutContext);
+  const { screenMarginBottom, resetScreenLayout } =
+    React.useContext(ScreenLayoutContext);
+
   const { currentRoute, screenData } = useNavigation();
+
   const screen = useCurrentScreenData();
 
   const { marginBottom, backgroundColor, paddingTop, paddingBottom } =
@@ -65,6 +68,10 @@ export const ScreenContainer = React.memo(function ScreenContainer({
   const theme = useTheme();
   const getThemeValue = React.useCallback(R.propOr(0, R.__, theme), [theme]);
 
+  React.useEffect(() => {
+    resetScreenLayout();
+  }, [currentRoute]);
+
   const fullscreen = React.useCallback(
     displayFullScreen({ currentRoute, screenData }),
     [currentRoute, screenData]

package/Components/Layout/TV/ScreenLayoutContextProvider.tsx

@@ -60,10 +60,15 @@ export function ScreenLayoutContextProvider(props: {
     initialState
   );
 
+  const resetScreenLayout = React.useCallback(() => {
+    setScreenLayout(initialState);
+  }, [initialState]);
+
   const screenLayoutValue = React.useMemo(
     () => ({
       ...screenLayout,
       setScreenLayout,
+      resetScreenLayout,
     }),
     [screenLayout]
   );

package/Components/Layout/TV/__tests__/ScreenContainer.test.tsx

@@ -56,11 +56,12 @@ describe("ScreenContainer", () => {
   };
 
   const setScreenLayout = () => {};
+  const resetScreenLayout = () => {};
 
   const wrapper = ({ children }) => (
     <WrappedWithProviders>
       <ScreenLayoutContext.Provider
-        value={{ ...screenLayout, setScreenLayout }}
+        value={{ ...screenLayout, setScreenLayout, resetScreenLayout }}
       >
         <ScreenContainer NavBar={View}>{children}</ScreenContainer>
       </ScreenLayoutContext.Provider>

package/Components/Layout/TV/__tests__/__snapshots__/NavBarContainer.test.tsx.snap

@@ -5,13 +5,14 @@ exports[`NavBarContainer renders 1`] = `
   style={
     [
       {
+        "flex": 1,
         "position": "absolute",
         "top": 0,
-        "width": 1920,
+        "width": "100%",
         "zIndex": 10,
       },
       {
-        "maxHeight": 10,
+        "maxHeight": 1,
       },
     ]
   }

package/Components/Layout/TV/__tests__/__snapshots__/ScreenContainer.test.tsx.snap

@@ -16,13 +16,14 @@ exports[`ScreenContainer renders 1`] = `
     style={
       [
         {
+          "flex": 1,
           "position": "absolute",
           "top": 0,
-          "width": 1920,
+          "width": "100%",
           "zIndex": 10,
         },
         {
-          "maxHeight": 10,
+          "maxHeight": 1,
         },
       ]
     }