@applicaster/zapp-react-native-ui-components 13.0.0-alpha.5771418585 → 13.0.0-alpha.5814285061

package/Components/Cell/TvOSCellComponent.tsx

@@ -2,7 +2,7 @@ import * as React from "react";
 import * as R from "ramda";
 import { View, StyleSheet } from "react-native";
 
-import { Focusable } from "@applicaster/zapp-react-native-ui-components/Components/Focusable";
+import { Focusable } from "@applicaster/zapp-react-native-ui-components/Components/Focusable/FocusableTvOS";
 import { FocusableCell } from "@applicaster/zapp-react-native-ui-components/Components/FocusableCell";
 import { getItemType } from "@applicaster/zapp-react-native-utils/navigationUtils";
 import { SCREEN_TYPES } from "@applicaster/zapp-react-native-utils/navigationUtils/itemTypes";
@@ -65,6 +65,7 @@ type Props = {
   isFocusable: boolean;
   shouldUpdate: boolean;
   behavior: Behavior;
+  componentsMapOffset: number;
 };
 
 type State = {
@@ -179,6 +180,7 @@ export class TvOSCellComponent extends React.Component<Props, State> {
       groupId,
       component,
       index,
+      componentsMapOffset,
     } = this.props;
 
     this.setScreenLayout(componentAnchorPointY, screenLayout);
@@ -193,13 +195,11 @@ export class TvOSCellComponent extends React.Component<Props, State> {
       const extraAnchorPointYOffset =
         screenLayout?.extraAnchorPointYOffset || 0;
 
-      const marginTop = screenLayout?.screenMarginTop || 0;
-
       const totalOffset =
         headerOffset +
-        (componentAnchorPointY || 0) +
-        extraAnchorPointYOffset -
-        marginTop;
+          (componentAnchorPointY || 0) +
+          extraAnchorPointYOffset -
+          componentsMapOffset || 0;
 
       mainOffsetUpdater?.(
         { tag: this.target },
@@ -247,7 +247,7 @@ export class TvOSCellComponent extends React.Component<Props, State> {
 
     const focusableId = R.join("-", [component?.id, id, index]);
 
-    const handleFocus = (arg1: any, index: number) => {
+    const handleFocus = (arg1: any, index?: number) => {
       const focusFn = onFocus || noop;
       focusFn(arg1, index);
 
@@ -280,7 +280,7 @@ export class TvOSCellComponent extends React.Component<Props, State> {
       <View onLayout={this.onLayout} style={styles.container}>
         <Focusable
           id={focusableId}
-          groupId={groupId || component?.id}
+          groupId={String(groupId || component?.id)}
           onFocus={handleFocus}
           onBlur={onBlur || this.onBlur}
           isParallaxDisabled={this.layout?.width > 1740}
@@ -292,20 +292,18 @@ export class TvOSCellComponent extends React.Component<Props, State> {
           style={baseCellStyles}
           isFocusable={isFocusable}
         >
-          {(focused) => {
-            return (
-              <FocusableCell
-                {...{
-                  index,
-                  CellRenderer,
-                  item,
-                  focused: this.props.focused || selectedCell || focused,
-                  scrollTo: this.scrollTo,
-                  behavior,
-                }}
-              />
-            );
-          }}
+          {(focused) => (
+            <FocusableCell
+              {...{
+                index,
+                CellRenderer,
+                item,
+                focused: !!(this.props.focused || selectedCell || focused),
+                scrollTo: this.scrollTo,
+                behavior,
+              }}
+            />
+          )}
         </Focusable>
       </View>
     );

package/Components/Cell/index.js

@@ -11,6 +11,7 @@ import { ScreenScrollingContext } from "../../Contexts/ScreenScrollingContext";
 
 import { ScreenLayoutContextConsumer } from "../../Contexts/ScreenLayoutContext";
 import { createContext } from "@applicaster/zapp-react-native-utils/reactUtils/createContext";
+import { withComponentsMapOffsetContextConsumer } from "../../Contexts/ComponentsMapOffsetContext";
 
 // TODO | Gallery QB | Extract this
 export const ScrollInterceptorContext = createContext(
@@ -30,5 +31,6 @@ export const Cell = R.compose(
   RiverOffsetContext.withConsumer,
   HorizontalScrollContext.withConsumer,
   withConsumer,
-  ScreenLayoutContextConsumer
+  ScreenLayoutContextConsumer,
+  withComponentsMapOffsetContextConsumer
 )(Component);

package/Components/Cell/styles.ts

@@ -0,0 +1,17 @@
+import { StyleSheet } from "react-native";
+
+export const styles = StyleSheet.create({
+  cellWrapper: {
+    flex: 0,
+    height: "100%",
+  },
+  baseCell: {
+    height: "100%",
+    display: "flex",
+    flex: 1,
+  },
+  touchableCell: {
+    flex: 1,
+    height: "100%",
+  },
+});

package/Components/CellRendererResolver/__tests__/cellRendererResolver.test.js

@@ -1,6 +1,7 @@
 import * as React from "react";
 import { View } from "react-native";
-import { shallow } from "enzyme";
+import { render } from "@testing-library/react-native";
+import { CellRendererResolver } from "../";
 
 jest.mock("../../default-cell-renderer", () => {
   const View = jest.requireActual("react-native").View;
@@ -8,8 +9,6 @@ jest.mock("../../default-cell-renderer", () => {
   return jest.fn((prop) => <View whoAmI="default renderer" someProp={prop} />);
 });
 
-const { CellRendererResolver } = require("../index");
-
 const component = {
   styles: {
     cell_plugin_configuration_id: "ABCDE-123456",
@@ -45,17 +44,9 @@ describe("CellRendererResolver", () => {
       cellStyles,
     });
 
-  it("renders correctly", () => {
-    const result = shallow(
-      getResult({ component, plugins, styles, cellStyles })
-    );
-
-    expect(result).toMatchSnapshot();
-  });
-
   describe("with a default renderer plugin", () => {
     it("renders correctly", () => {
-      const result = shallow(
+      const { UNSAFE_root } = render(
         getResult({
           component,
           plugins,
@@ -64,56 +55,63 @@ describe("CellRendererResolver", () => {
         })
       );
 
-      expect(result).toMatchSnapshot();
+      expect(UNSAFE_root).toBeDefined();
     });
 
     it("returns default plugin if component has no cell_plugin_configuration_id", () => {
-      const result = getResult({
-        component: {},
-        plugins,
-        styles,
-        cellStyles,
-      });
-
-      expect(result).toBeDefined();
-      expect(result.props.whoAmI).toEqual("default renderer");
+      const { UNSAFE_getByProps } = render(
+        getResult({
+          component: {},
+          plugins,
+          styles,
+          cellStyles,
+        })
+      );
+
+      expect(UNSAFE_getByProps({ whoAmI: "default renderer" })).toBeTruthy();
     });
 
     it("returns default plugin if requested cell plugin configuration does not exist", () => {
-      const result = getResult({
-        component: { styles: { cell_plugin_configuration_id: "wrong-id" } },
-        plugins,
-        styles,
-        cellStyles,
-      });
-
-      expect(result.props.whoAmI).toEqual("default renderer");
+      const { UNSAFE_getByProps } = render(
+        getResult({
+          component: { styles: { cell_plugin_configuration_id: "wrong-id" } },
+          plugins,
+          styles,
+          cellStyles,
+        })
+      );
+
+      expect(UNSAFE_getByProps({ whoAmI: "default renderer" })).toBeTruthy();
     });
 
     it("returns default plugin if cellStyles store is empty", () => {
-      const result = getResult({
-        component,
-        plugins,
-        styles,
-        cellStyles: {},
-      });
-
-      expect(result.props.whoAmI).toEqual("default renderer");
+      const { UNSAFE_getByProps } = render(
+        getResult({
+          component,
+          plugins,
+          styles,
+          cellStyles: {},
+        })
+      );
+
+      expect(UNSAFE_getByProps({ whoAmI: "default renderer" })).toBeTruthy();
     });
 
     it("returns null if requested renderer plugin does not exist", () => {
-      const result = getResult({
-        component: {
-          styles: {
-            cell_plugin_configuration_id: "FGHIJ-123456",
+      const { UNSAFE_getByProps } = render(
+        getResult({
+          component: {
+            styles: {
+              cell_plugin_configuration_id: "FGHIJ-123456",
+            },
           },
-        },
-        plugins,
-        styles,
-        cellStyles,
-      });
+          plugins,
+          styles,
+          cellStyles,
+        })
+      );
 
-      expect(result.props.whoAmI).toEqual("default renderer");
+      expect(UNSAFE_getByProps({ whoAmI: "default renderer" })).toBeTruthy();
     });
   });
 });

package/Components/CellRendererResolver/index.ts

@@ -1,4 +1,5 @@
 import { findPluginByIdentifier } from "@applicaster/zapp-react-native-utils/pluginUtils";
+import { isGroup } from "@applicaster/zapp-react-native-utils/componentsUtils";
 
 import { componentsLogger } from "../../Helpers/logger";
 import defaultCellRenderer from "../default-cell-renderer";
@@ -80,7 +81,7 @@ export function CellRendererResolver({
 }: Props) {
   const cellRendererPlugin = getRendererPlugin(component, plugins, cellStyles);
 
-  if (!cellRendererPlugin && component.component_type !== "group-qb") {
+  if (!cellRendererPlugin && !isGroup(component)) {
     logger.warning({
       message: "Could not resolve cell builder plugin",
       data: { component },

package/Components/ComponentResolver/__tests__/__snapshots__/componentResolver.test.js.snap

@@ -1,48 +1,7 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
-exports[`ComponentResolver renders correctly 1`] = `
-<ContextProvider
-  value={null}
->
-  <Memo(ComponentResolver)
-    cellStyles={{}}
-    component={
-      {
-        "component_type": "some_component",
-      }
-    }
-    components={
-      {
-        "SomeComponent": [MockFunction],
-      }
-    }
-    decorators={[MockFunction]}
-    dispatch={[Function]}
-    plugins={[]}
-    store={
-      {
-        "clearActions": [Function],
-        "dispatch": [Function],
-        "getActions": [Function],
-        "getState": [Function],
-        "replaceReducer": [Function],
-        "subscribe": [Function],
-      }
-    }
-  />
-</ContextProvider>
-`;
-
 exports[`ComponentResolverComponent initializes the cell renderer plugin module if matching plugin exists 1`] = `
-<mockConstructor
+<View
   rendered={true}
 />
 `;
-
-exports[`ComponentResolverComponent renders the Component if it exists 1`] = `
-<mockConstructor
-  rendered={true}
-/>
-`;
-
-exports[`ComponentResolverComponent returns null if the component doesn't exist 1`] = `""`;

package/Components/ComponentResolver/__tests__/componentResolver.test.js

@@ -1,7 +1,6 @@
 import * as React from "react";
 import { View } from "react-native";
-import { shallow } from "enzyme";
-import { shallowToJson } from "enzyme-to-json";
+import { render } from "@testing-library/react-native";
 import configureStore from "redux-mock-store";
 
 const mockLogger = {
@@ -43,37 +42,36 @@ const store = configureStore()({
 });
 
 const component = { component_type: "some_component" };
-const decorators = jest.fn((x) => x);
+const decorators = (x) => x;
 const renderFunction = jest.fn((Comp) => <Comp rendered />);
 
 function clearAllMocks() {
-  SomeComponent.mockClear();
-  decorators.mockClear();
-  renderFunction.mockClear();
-  mockLogger.warning.mockClear();
+  jest.clearAllMocks();
 }
 
 describe("ComponentResolver", () => {
   beforeEach(clearAllMocks);
 
   it("renders correctly", () => {
-    const wrapper = shallow(
+    const { toJSON } = render(
       <ComponentResolver
         component={component}
         decorators={decorators}
         store={store}
-      />
+      >
+        {() => null}
+      </ComponentResolver>
     );
 
-    expect(shallowToJson(wrapper)).toMatchSnapshot();
+    expect(toJSON()).toBeNull();
   });
 });
 
 describe("ComponentResolverComponent", () => {
   beforeEach(clearAllMocks);
 
-  const getWrapper = (component, plugins) =>
-    shallow(
+  const renderComponent = (component, plugins) =>
+    render(
       <ComponentResolverComponent
         components={components}
         component={component}
@@ -87,9 +85,9 @@ describe("ComponentResolverComponent", () => {
     );
 
   it("renders the Component if it exists", () => {
-    const wrapper = getWrapper(component, plugins);
+    const { toJSON } = renderComponent(component, plugins);
 
-    expect(shallowToJson(wrapper)).toMatchSnapshot();
+    expect(toJSON()).not.toBeNull();
 
     expect(renderFunction).toHaveBeenCalledWith(
       SomeComponent,
@@ -98,14 +96,12 @@ describe("ComponentResolverComponent", () => {
   });
 
   it("returns null if the component doesn't exist", () => {
-    const wrapper = getWrapper({ component_type: "foo" }, plugins);
+    const { UNSAFE_root } = renderComponent({ component_type: "foo" }, plugins);
 
     const warningMessage =
       "Component foo cannot be found - it is skipped from rendering";
 
-    expect(shallowToJson(wrapper)).toMatchSnapshot();
-    expect(wrapper.isEmptyRender()).toBe(true);
-
+    expect(UNSAFE_root.children.length).toBe(0);
     expect(mockLogger.warning).toHaveBeenCalledTimes(2);
 
     expect(mockLogger.warning).toHaveBeenNthCalledWith(
@@ -124,11 +120,9 @@ describe("ComponentResolverComponent", () => {
   });
 
   it("initializes the cell renderer plugin module if matching plugin exists", () => {
-    const plugins = [];
-
-    const wrapper = getWrapper(component, plugins);
+    const { toJSON } = renderComponent(component, plugins);
 
-    expect(shallowToJson(wrapper)).toMatchSnapshot();
+    expect(toJSON()).toMatchSnapshot();
 
     expect(renderFunction).toHaveBeenCalledWith(
       SomeComponent,

package/Components/ContentScreen/__tests__/contentScreen.test.js

@@ -1,10 +1,10 @@
 import React from "react";
-import { shallow } from "enzyme";
+import { render } from "@testing-library/react-native";
 
-import { ContentScreen } from "../index";
+import { ContentScreen } from "../";
 
 describe("<ContentScreen />", () => {
   it("renders correctly", () => {
-    expect(() => shallow(<ContentScreen />)).toThrowErrorMatchingSnapshot();
+    expect(() => render(<ContentScreen />)).toThrowErrorMatchingSnapshot();
   });
 });

package/Components/ErrorScreen/index.tsx

@@ -105,6 +105,11 @@ const defaultProps = {
       alignItems: "center",
       justifyContent: "center",
     },
+    focusedButton: {
+      backgroundColor: "#3a3a3a",
+      borderColor: "#ffffff",
+      borderWidth: 2,
+    },
     buttonText: {
       fontFamily: platformSelect({
         ios: "SFProText-Medium",
@@ -116,6 +121,9 @@ const defaultProps = {
       color: "rgba(255, 255, 255, 1)",
       textTransform: "uppercase",
     },
+    focusedText: {
+      color: "#ffffff",
+    },
   },
 };
 

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>