@applicaster/zapp-react-native-ui-components 12.0.0-alpha.3510522252 → 12.0.0-alpha.3977160850

package/Components/ModalComponent/Header/utils.ts

@@ -0,0 +1,79 @@
+import * as R from "ramda";
+import { platformSelect } from "@applicaster/zapp-react-native-utils/reactUtils";
+import { PluginConfiguration } from "../index";
+
+export function getCloseButtonProps(config: PluginConfiguration) {
+  const {
+    modal_bottom_sheet_close_asset,
+    modal_bottom_sheet_close_focus_asset,
+    modal_bottom_sheet_close_height,
+    modal_bottom_sheet_close_width,
+    modal_bottom_sheet_close_switch,
+    modal_bottom_sheet_close_margin_bottom,
+    modal_bottom_sheet_close_margin_left,
+    modal_bottom_sheet_close_margin_right,
+    modal_bottom_sheet_close_margin_top,
+  } = config;
+
+  return {
+    asset: modal_bottom_sheet_close_asset,
+    assetFocused: modal_bottom_sheet_close_focus_asset,
+    enabled: modal_bottom_sheet_close_switch,
+    width: modal_bottom_sheet_close_width,
+    height: modal_bottom_sheet_close_height,
+    marginTop: modal_bottom_sheet_close_margin_top,
+    marginBottom: modal_bottom_sheet_close_margin_bottom,
+    marginLeft: modal_bottom_sheet_close_margin_left,
+    marginRight: modal_bottom_sheet_close_margin_right,
+  };
+}
+
+export function getTextValue(
+  config: PluginConfiguration,
+  entry: ZappEntry,
+  key: string
+): string {
+  const keyValue = config[key];
+
+  if (entry) {
+    const keyPath = R.split(".", keyValue);
+
+    return R.path(keyPath, entry);
+  } else {
+    return keyValue;
+  }
+}
+
+function getConfigKey(
+  config: PluginConfiguration,
+  suffix: string,
+  key: "title" | "summary"
+) {
+  return config?.[`modal_bottom_sheet_${key}_${suffix}`];
+}
+
+export function getTitleProps(
+  config: PluginConfiguration,
+  key: "title" | "summary"
+) {
+  return {
+    enabled: getConfigKey(config, "switch", key),
+    letterSpacing: platformSelect({
+      ios: getConfigKey(config, "ios_letter_spacing", key),
+      android: getConfigKey(config, "android_letter_spacing", key),
+    }),
+    fontFamily: platformSelect({
+      ios: getConfigKey(config, "family_ios_font_selector", key),
+      android: getConfigKey(config, "family_android_font_selector", key),
+    }),
+    lineHeight: getConfigKey(config, "line_height", key),
+    fontSize: getConfigKey(config, "font_size", key),
+    color: getConfigKey(config, "font_color", key),
+    marginTop: getConfigKey(config, "margin_top", key),
+    marginBottom: getConfigKey(config, "margin_bottom", key),
+    marginLeft: getConfigKey(config, "margin_left", key),
+    marginRight: getConfigKey(config, "margin_right", key),
+    numberOfLines: getConfigKey(config, "number_of_lines", key),
+    transform: getConfigKey(config, "transform", key),
+  };
+}

package/Components/ModalComponent/index.tsx

@@ -0,0 +1,38 @@
+import React, { useCallback, useState } from "react";
+
+import { BasicMeasurementsPortal as MeasurementsPortal } from "@applicaster/zapp-react-native-ui-components/Components/MeasurmentsPortal";
+import { BottomSheetModalContent } from "./BottomSheetModalContent";
+
+export type PluginConfiguration = {
+  [key: string]: any;
+};
+
+type Props = {
+  actionPlugins?: [QuickBrickPlugin];
+  configuration?: PluginConfiguration;
+};
+
+export function ModalComponent(props: ModalBottomSheetContentProps & Props) {
+  const [height, setHeight] = useState(0);
+
+  const onLayout = useCallback(
+    ({ nativeEvent }) => {
+      if (height === 0) {
+        setHeight(nativeEvent.layout.height);
+      }
+    },
+    [height]
+  );
+
+  if (height === 0) {
+    return (
+      <MeasurementsPortal
+        Component={BottomSheetModalContent}
+        componentProps={props}
+        onLayout={onLayout}
+      />
+    );
+  }
+
+  return <BottomSheetModalContent {...props} />;
+}

package/Components/ModalComponent/utils.ts

@@ -0,0 +1,126 @@
+import { platformSelect } from "@applicaster/zapp-react-native-utils/reactUtils";
+import { PluginConfiguration } from "./index";
+
+export function defaultItemProps(
+  config: PluginConfiguration,
+  maxWidth: number
+) {
+  const {
+    modal_bottom_sheet_item_background_color,
+    modal_bottom_sheet_item_focus_background_color,
+    modal_bottom_sheet_item_selected_background_color,
+    modal_bottom_sheet_item_focusected_background_color,
+    modal_bottom_sheet_item_corner_radius,
+    modal_bottom_sheet_item_margin_bottom,
+    modal_bottom_sheet_item_margin_left,
+    modal_bottom_sheet_item_margin_right,
+    modal_bottom_sheet_item_margin_top,
+    modal_bottom_sheet_item_padding_bottom,
+    modal_bottom_sheet_item_padding_left,
+    modal_bottom_sheet_item_padding_right,
+    modal_bottom_sheet_item_padding_top,
+  } = config;
+
+  return {
+    backgroundColor: modal_bottom_sheet_item_background_color,
+    focusedBackgroundColor: modal_bottom_sheet_item_focus_background_color,
+    selectedBackgroundColor: modal_bottom_sheet_item_selected_background_color,
+    focusectedBackgroundColor:
+      modal_bottom_sheet_item_focusected_background_color,
+    borderRadius: modal_bottom_sheet_item_corner_radius,
+    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,
+    paddingRight: modal_bottom_sheet_item_padding_right,
+    paddingLeft: modal_bottom_sheet_item_padding_left,
+    maxWidth,
+  };
+}
+
+export function defaultItemLabelProps(
+  config: PluginConfiguration,
+  sheetWidth: number
+) {
+  const {
+    modal_bottom_sheet_item_label_android_letter_spacing,
+    modal_bottom_sheet_item_label_ios_letter_spacing,
+    modal_bottom_sheet_item_label_family_ios_font_selector,
+    modal_bottom_sheet_item_label_family_android_font_selector,
+    modal_bottom_sheet_item_label_focus_font_color,
+    modal_bottom_sheet_item_label_font_color,
+    modal_bottom_sheet_item_label_selected_font_color,
+    modal_bottom_sheet_item_label_hover_selected_font_color,
+    modal_bottom_sheet_item_label_font_size,
+    modal_bottom_sheet_item_label_line_height,
+    modal_bottom_sheet_item_label_margin_bottom,
+    modal_bottom_sheet_item_label_margin_top,
+    modal_bottom_sheet_item_label_margin_left,
+    modal_bottom_sheet_item_label_margin_right,
+    modal_bottom_sheet_item_label_transform,
+    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,
+  } = config;
+
+  const maxWidth =
+    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);
+
+  return {
+    fontFamily: platformSelect({
+      ios: modal_bottom_sheet_item_label_family_ios_font_selector,
+      android: modal_bottom_sheet_item_label_family_android_font_selector,
+    }),
+    letterSpacing: platformSelect({
+      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,
+    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,
+    lineHeight: modal_bottom_sheet_item_label_line_height,
+    marginBottom: modal_bottom_sheet_item_label_margin_bottom,
+    marginTop: modal_bottom_sheet_item_label_margin_top,
+    marginLeft: modal_bottom_sheet_item_label_margin_left,
+    marginRight: modal_bottom_sheet_item_label_margin_right,
+    transform: modal_bottom_sheet_item_label_transform,
+    maxWidth,
+  };
+}
+
+export function defaultItemIconProps(config: PluginConfiguration) {
+  const {
+    modal_bottom_sheet_item_icon_height,
+    modal_bottom_sheet_item_icon_width,
+    modal_bottom_sheet_item_icon_margin_bottom,
+    modal_bottom_sheet_item_icon_margin_left,
+    modal_bottom_sheet_item_icon_margin_right,
+    modal_bottom_sheet_item_icon_margin_top,
+    modal_bottom_sheet_item_icon_flavour,
+  } = config;
+
+  return {
+    width: modal_bottom_sheet_item_icon_width,
+    height: modal_bottom_sheet_item_icon_height,
+    flavour: modal_bottom_sheet_item_icon_flavour,
+    marginTop: modal_bottom_sheet_item_icon_margin_top,
+    marginBottom: modal_bottom_sheet_item_icon_margin_bottom,
+    marginLeft: modal_bottom_sheet_item_icon_margin_left,
+    marginRight: modal_bottom_sheet_item_icon_margin_right,
+  };
+}

package/Components/PlayerContainer/PlayerContainer.tsx

@@ -580,8 +580,6 @@ const PlayerContainerComponent = (props: Props) => {
     pluginConfiguration,
   };
 
-  console.log("Anton player container", {result: {isAppleTV: isAppleTV(), notInlineTv: !isInlineTV}});
-
   return (
     <PlayerStateContext.Provider value={value}>
       <PlayerContainerContextProvider
@@ -623,7 +621,7 @@ const PlayerContainerComponent = (props: Props) => {
                         }}
                         focused={isInlineTV ? true : undefined}
                         autoplay={true}
-                        controls={false}
+                        controls={isAppleTV() && !isInlineTV}
                         disableCastAction={disableCastAction}
                         docked={navigator.isVideoModalDocked()}
                         entry={item}

package/Components/River/ComponentsMap/ComponentsMap.tsx

@@ -21,6 +21,7 @@ import {
 import { useScreenData } from "@applicaster/zapp-react-native-utils/reactHooks/screen/useScreenData";
 import { isLast } from "@applicaster/zapp-react-native-utils/arrayUtils";
 import { withComponentsMapProvider } from "@applicaster/zapp-react-native-ui-components/Decorators/ComponentsMapWrapper";
+import { useScreenScrollStore } from "@applicaster/zapp-react-native-utils/screenState";
 
 type Props = {
   feed: ZappFeed;
@@ -193,6 +194,27 @@ function ComponentsMapComponent(props: Props) {
     []
   );
 
+  const onScrollFlatList = React.useCallback(
+    ({ nativeEvent }, isScrollingDone = false) => {
+      const {
+        contentOffset: { y },
+      } = nativeEvent;
+
+      useScreenScrollStore.setState({
+        scrollingVelocity: isScrollingDone ? 0 : 1,
+        scrollPosition: y,
+      });
+    },
+    []
+  );
+
+  const onMomentumScrollEnd = React.useCallback(
+    ({ nativeEvent }) => {
+      onScrollFlatList({ nativeEvent }, true);
+    },
+    [onScrollFlatList]
+  );
+
   if (shouldShowLoadingError) {
     return <RiverError />;
   }
@@ -227,6 +249,9 @@ function ComponentsMapComponent(props: Props) {
             }
             ListFooterComponent={renderFooter}
             refreshControl={refreshControl}
+            onScroll={onScrollFlatList}
+            onMomentumScrollEnd={onMomentumScrollEnd}
+            scrollEventThrottle={16}
             {...scrollViewExtraProps}
           />
         </ViewportTracker>

package/Components/River/TV/River.tsx

@@ -4,7 +4,6 @@ import * as React from "react";
 import { Text } from "react-native";
 import * as R from "ramda";
 
-import { usePickFromState } from "@applicaster/zapp-react-native-redux/hooks";
 import {
   useFeedLoader,
   useLayoutVersion,
@@ -20,6 +19,7 @@ import {
   useNavbarState,
   useSetNavbarState,
 } from "@applicaster/zapp-react-native-utils/reactHooks/screen/useScreenContext";
+import { useRivers } from "@applicaster/zapp-react-native-utils/reactHooks/state";
 
 type Props = {
   screenId: string;
@@ -53,7 +53,7 @@ export const River = (props: Props) => {
 
   const navigationPluginData = useNavigationPluginData();
 
-  const { rivers } = usePickFromState(["rivers"]);
+  const rivers = useRivers();
   const isV2 = useLayoutVersion({ isV2: true });
 
   const river = React.useMemo(() => rivers?.[screenId], [screenId]);

package/Components/River/__tests__/__snapshots__/componentsMap.test.js.snap

@@ -64,7 +64,7 @@ exports[`componentsMap renders renders components map correctly 1`] = `
       refreshControl={null}
       removeClippedSubviews={true}
       renderItem={[Function]}
-      scrollEventThrottle={50}
+      scrollEventThrottle={16}
       scrollIndicatorInsets={
         Object {
           "right": 1,

package/Components/River/useScreenConfiguration.ts

@@ -1,10 +1,10 @@
 import * as R from "ramda";
 
-import { usePickFromState } from "@applicaster/zapp-react-native-redux/hooks";
 import { useIsTablet } from "@applicaster/zapp-react-native-utils/reactHooks";
 import { toCamelCase } from "@applicaster/zapp-react-native-utils/stringUtils";
 import { useMemo } from "react";
 import { isNilOrEmpty } from "@applicaster/zapp-react-native-utils/reactUtils/helpers";
+import { useRivers } from "@applicaster/zapp-react-native-utils/reactHooks/state";
 
 type GeneralContentScreen = ZappRiver & {
   styles: {
@@ -46,7 +46,7 @@ const stylingKeys = [
 ];
 
 export function useScreenConfiguration(screenId: string): ScreenConfiguration {
-  const { rivers } = usePickFromState(["rivers"]);
+  const rivers = useRivers();
   const isTablet = useIsTablet();
 
   return useMemo(() => {

package/Components/RouteManager/__tests__/__snapshots__/routeManager.test.js.snap

@@ -5,6 +5,7 @@ exports[`<RouteManager /> renders correctly 1`] = `
   screenId="A1234"
 >
   <WithProvider
+    pathname="/river/A1234"
     screenData={
       Object {
         "id": "A1234",

package/Components/RouteManager/__tests__/routeManager.test.js

@@ -2,11 +2,17 @@ import React from "react";
 import { shallow } from "enzyme";
 import { shallowToJson } from "enzyme-to-json";
 
-import { ScreenResolver } from "@applicaster/zapp-react-native-ui-components/Components/ScreenResolver";
-
 const pathname = "/river/A1234";
 const screenData = { id: "A1234" };
 
+jest.mock("@applicaster/zapp-react-native-utils/reactHooks/navigation", () => ({
+  useRoute: jest.fn(() => ({ pathname: pathname, screenData: screenData })),
+}));
+
+const {
+  ScreenResolver,
+} = require("@applicaster/zapp-react-native-ui-components/Components/ScreenResolver");
+
 const { RouteManager } = require("../index");
 
 describe("<RouteManager />", () => {
@@ -20,6 +26,7 @@ describe("<RouteManager />", () => {
 
   it("passes the correct props to ScreenResolver", () => {
     expect(wrapper.find(ScreenResolver).props()).toEqual({
+      pathname: "/river/A1234",
       screenType: "river",
       screenId: "A1234",
       screenData: { id: "A1234" },

package/Components/RouteManager/index.tsx

@@ -2,6 +2,7 @@ import * as React from "react";
 import * as R from "ramda";
 
 import { getPathAttributes } from "@applicaster/zapp-react-native-utils/navigationUtils";
+import { useRoute } from "@applicaster/zapp-react-native-utils/reactHooks";
 import { ScreenResolver } from "../ScreenResolver";
 import { TestId } from "./TestId";
 
@@ -12,7 +13,8 @@ type Props = { pathname: string; screenData: Record<string, any> };
  * and reconciles data returned from hook plugins if needed
  * @param {Props}: see props above
  */
-export function RouteManager({ pathname, screenData, ...otherProps }: Props) {
+export function RouteManager(props: Props) {
+  const { pathname, screenData } = useRoute();
   const pathAttributes = getPathAttributes({ pathname });
 
   const { screenType, screenId } = R.last(pathAttributes);
@@ -22,8 +24,8 @@ export function RouteManager({ pathname, screenData, ...otherProps }: Props) {
       <ScreenResolver
         screenType={screenType}
         screenId={screenId}
+        {...props}
         screenData={screenData}
-        {...otherProps}
       />
     </TestId>
   );

package/Components/Screen/__tests__/Screen.test.tsx

@@ -6,6 +6,14 @@ const Mocked_RouteManager = jest.fn((props) => (
   <View testID="routeManager" {...props} />
 ));
 
+const mock_navBarVisibleFlag = true;
+
+const mockIsNavBarVisible = jest.fn(() => mock_navBarVisibleFlag);
+
+jest.mock("react-native-safe-area-context", () => ({
+  useSafeAreaInsets: () => ({ top: 44 }),
+}));
+
 jest.mock("../../RouteManager", () => ({
   RouteManager: Mocked_RouteManager,
 }));
@@ -23,51 +31,42 @@ jest.mock(
   })
 );
 
-let mock_navBarVisibleFlag = true;
-
-jest.mock("../navigationHandler.ts", () => ({
-  isNavBarVisible: jest.fn(() => mock_navBarVisibleFlag),
-}));
-
 jest.mock("@applicaster/zapp-react-native-utils/analyticsUtils", () => ({
   useAnalytics: jest.fn(() => ({
     sendScreenEvent: jest.fn(),
   })),
 }));
 
-const {
-  allowedOrientationsForScreen,
-  getOrientation,
-  useGetScreenOrientation,
-} = require("@applicaster/zapp-react-native-utils/appUtils/orientationHelper");
-
 jest.mock("@applicaster/zapp-react-native-utils/theme", () => ({
   useTheme: jest.fn(() => ({
     app_background_color: "blue",
   })),
 }));
 
+const NavBar = jest.fn((props) => <View testID="navBar" {...props} />);
+
+jest.mock(
+  "@applicaster/zapp-react-native-app/App/Layout/layoutHelpers",
+  () => ({
+    getNavigationPluginModule: () => NavBar,
+  })
+);
+
 jest.mock("@applicaster/zapp-react-native-utils/reactHooks/screen", () => ({
-  useCurrentScreenData: jest.fn(() => ({
+  ...(jest.requireActual(
+    "@applicaster/zapp-react-native-utils/reactHooks/screen"
+  ) as any),
+  useScreenData: jest.fn(() => ({
     id: "testId",
+    navigations: [{ id: "testId", category: "nav_bar" }],
   })),
-  useNavbarState: jest.fn(() => ({
-    visible: jest.fn(() => mock_navBarVisibleFlag),
+  useCurrentScreenData: jest.fn(() => ({
+    id: "testId",
   })),
 }));
 
-const {
-  useCurrentScreenData,
-} = require("@applicaster/zapp-react-native-utils/reactHooks/screen");
-
-const { isNavBarVisible } = require("../navigationHandler");
-
-const NavBar = jest.fn((props) => <View testID="navBar" {...props} />);
-const navigator = {};
-const navBarProps = { nav_items: [] };
-const screenData = {};
-
 jest.mock("@applicaster/zapp-react-native-utils/reactHooks/navigation", () => ({
+  isNavBarVisible: mockIsNavBarVisible,
   useRoute: jest.fn(() => ({
     pathname: "/river/testId",
   })),
@@ -93,9 +92,26 @@ jest.mock("@applicaster/zapp-react-native-redux/hooks", () => ({
   }),
 }));
 
+const {
+  ORIENTATIONS,
+} = require("@applicaster/zapp-react-native-utils/appUtils/orientationHelper");
+
+const {
+  useCurrentScreenData,
+} = require("@applicaster/zapp-react-native-utils/reactHooks/screen");
+
+const {
+  allowedOrientationsForScreen,
+  getOrientation,
+  useGetScreenOrientation,
+} = require("@applicaster/zapp-react-native-utils/appUtils/orientationHelper");
+
+const navigator = {};
+const navBarProps = { nav_items: [] };
+const screenData = {};
+
 const screenProps = {
   pathname: "/foo/path",
-  NavBar,
   navigator,
   navBarProps,
   screenData,
@@ -109,7 +125,6 @@ describe("<Screen Component />", () => {
   beforeEach(() => {
     allowedOrientationsForScreen.mockClear();
     getOrientation.mockClear();
-    isNavBarVisible.mockClear();
     useGetScreenOrientation.mockClear();
   });
 
@@ -125,14 +140,9 @@ describe("<Screen Component />", () => {
 
   describe("when the navbar should be hidden", () => {
     beforeEach(() => {
-      mock_navBarVisibleFlag = false;
       wrapper = create(<Screen {...screenProps} />);
     });
 
-    afterEach(() => {
-      mock_navBarVisibleFlag = true;
-    });
-
     it("renders correctly", () => {
       act(() => {
         wrapper = create(<Screen {...screenProps} />);
@@ -142,44 +152,44 @@ describe("<Screen Component />", () => {
     });
   });
 
-  // it("invokes the orientation hook when the route changes", () => {
-  //   act(() => {
-  //     wrapper = create(<Screen {...screenProps} />);
-  //   });
-
-  //   // @ts-ignore
-  //   useCurrentScreenData.mockReturnValue({
-  //     id: "player-testId",
-  //     general: { screen_orientation: ORIENTATIONS.landscapeSensor },
-  //     plugin_type: "player",
-  //   });
-
-  //   act(() => {
-  //     wrapper.update(
-  //       <Screen
-  //         {...screenProps}
-  //         pathname="/playable"
-  //         screenData={{
-  //           id: "player-testId",
-  //           general: { screen_orientation: ORIENTATIONS.landscapeSensor },
-  //           plugin_type: "player",
-  //         }}
-  //       />
-  //     );
-  //   });
-
-  //   useCurrentScreenData.mockReturnValue({
-  //     id: "player-testId",
-  //     general: { screen_orientation: ORIENTATIONS.landscapeSensor },
-  //   });
-
-  //   act(() => {
-  //     wrapper.update(<Screen {...screenProps} />);
-  //   });
-
-  //   expect(allowedOrientationsForScreen).toHaveBeenNthCalledWith(
-  //     1,
-  //     ORIENTATIONS.landscapeSensor
-  //   );
-  // });
+  it("invokes the orientation hook when the route changes", () => {
+    act(() => {
+      wrapper = create(<Screen {...screenProps} />);
+    });
+
+    // @ts-ignore
+    useCurrentScreenData.mockReturnValue({
+      id: "player-testId",
+      general: { screen_orientation: ORIENTATIONS.landscapeSensor },
+      plugin_type: "player",
+    });
+
+    act(() => {
+      wrapper.update(
+        <Screen
+          {...screenProps}
+          pathname="/playable"
+          screenData={{
+            id: "player-testId",
+            general: { screen_orientation: ORIENTATIONS.landscapeSensor },
+            plugin_type: "player",
+          }}
+        />
+      );
+    });
+
+    useCurrentScreenData.mockReturnValue({
+      id: "player-testId",
+      general: { screen_orientation: ORIENTATIONS.landscapeSensor },
+    });
+
+    act(() => {
+      wrapper.update(<Screen {...screenProps} />);
+    });
+
+    expect(allowedOrientationsForScreen).toHaveBeenNthCalledWith(
+      1,
+      ORIENTATIONS.landscapeSensor
+    );
+  });
 });