@applicaster/zapp-react-native-ui-components 13.0.0-alpha.1909212433 → 13.0.0-alpha.1952415373

package/Components/Cell/CellWithFocusable.tsx

@@ -1,52 +1,14 @@
 import * as React from "react";
 
-import { focusManager } from "@applicaster/zapp-react-native-utils/appUtils/focusManager";
-import * as FOCUS_EVENTS from "@applicaster/zapp-react-native-utils/appUtils/focusManager/events";
 import { noop } from "@applicaster/zapp-react-native-utils/functionUtils";
 import { toBooleanWithDefaultFalse } from "@applicaster/zapp-react-native-utils/booleanUtils";
 
-import { isAppleTV } from "../../Helpers/Platform";
 import { useCellState } from "../MasterCell/utils";
-
-const useCellFocusedState = (
-  skipFocusManagerRegistration: boolean,
-  groupId: string,
-  id: string
-) => {
-  const [currentCellFocused, setCurrentCellFocused] = React.useState(false);
-
-  React.useEffect(() => {
-    const isGroupItemFocused = () => {
-      if (!skipFocusManagerRegistration) {
-        const isFocused = focusManager.isGroupItemFocused(groupId, id);
-        setCurrentCellFocused(isFocused);
-      }
-    };
-
-    const handler = () => {
-      // tvOS hack for properly checking focus
-      if (isAppleTV()) {
-        setTimeout(() => {
-          isGroupItemFocused();
-        }, 0);
-      } else {
-        isGroupItemFocused();
-      }
-    };
-
-    focusManager.on(FOCUS_EVENTS.FOCUS, handler);
-
-    return () => {
-      focusManager.removeHandler(FOCUS_EVENTS.FOCUS, handler);
-    };
-  }, [groupId, skipFocusManagerRegistration]);
-
-  return currentCellFocused;
-};
+import { FocusableGroup } from "../FocusableGroup";
 
 type Props = {
   item: ZappEntry;
-  CellRenderer: React.ComponentType<{ item: Object; state: string }>;
+  CellRenderer: React.FunctionComponent<any>;
   id: string;
   groupId: string;
   onFocus: Function;
@@ -75,11 +37,7 @@ export function CellWithFocusable(props: Props) {
     focused,
   } = props;
 
-  const isFocused = useCellFocusedState(
-    skipFocusManagerRegistration,
-    groupId,
-    id
-  );
+  const [isFocused, setIsFocused] = React.useState(false);
 
   const state = useCellState({
     id: item.id,
@@ -96,26 +54,52 @@ export function CellWithFocusable(props: Props) {
     }
   }, [focusedButtonId]);
 
-  const handleToggleFocus = (value) => {
-    setFocusedButtonId(value.focusedButtonId);
+  const handleToggleFocus = React.useCallback(
+    (value) => {
+      setFocusedButtonId(value.focusedButtonId);
+
+      if (value.focusable) {
+        onFocus(value.focusable, value.mouse);
+      }
+    },
+    [onFocus]
+  );
+
+  const onGroupFocus = React.useCallback(() => {
+    if (!skipFocusManagerRegistration) {
+      setIsFocused(true);
+    }
+  }, [skipFocusManagerRegistration]);
 
-    if (value.focusable) {
-      onFocus(value.focusable, value.mouse);
+  const onGroupBlur = React.useCallback(() => {
+    if (!skipFocusManagerRegistration) {
+      setIsFocused(false);
     }
-  };
+  }, [skipFocusManagerRegistration]);
 
   return (
-    <CellRenderer
-      item={item}
+    <FocusableGroup
+      id={`focusable-cell-wrapper-${id}`}
+      testID={"cell-with-focusable-cell-renderer-focusable-group"}
       groupId={groupId}
-      onToggleFocus={handleToggleFocus}
-      state={state}
-      prefixId={id}
-      focusedButtonId={focusedButtonId}
       preferredFocus={preferredFocus}
-      skipFocusManagerRegistration={skipFocusManagerRegistration}
-      isFocusable={isFocusable}
-      focused={focused}
-    />
+      shouldUsePreferredFocus
+      onFocus={onGroupFocus}
+      onBlur={onGroupBlur}
+    >
+      <CellRenderer
+        testID={"cell-with-focusable-cell-renderer"}
+        item={item}
+        groupId={`focusable-cell-wrapper-${id}`}
+        onToggleFocus={handleToggleFocus}
+        state={state}
+        prefixId={id}
+        focusedButtonId={focusedButtonId}
+        preferredFocus={true}
+        skipFocusManagerRegistration={skipFocusManagerRegistration}
+        isFocusable={isFocusable}
+        focused={focused}
+      />
+    </FocusableGroup>
   );
 }

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/FocusableTvOS";
+import { Focusable } from "@applicaster/zapp-react-native-ui-components/Components/Focusable";
 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";
@@ -10,10 +10,6 @@ import { focusManager } from "@applicaster/zapp-react-native-utils/appUtils/focu
 import { sendSelectCellEvent } from "@applicaster/zapp-react-native-utils/analyticsUtils";
 import { noop } from "@applicaster/zapp-react-native-utils/functionUtils";
 import { CellWithFocusable } from "./CellWithFocusable";
-import { getCellState } from "./utils";
-
-const _getCellState = (focused, selected) =>
-  getCellState({ focused, selected });
 
 type Props = {
   item: ZappEntry;
@@ -36,10 +32,9 @@ type Props = {
     component_type: string;
   };
   selected: boolean;
-  CellRenderer: React.ComponentType<{
-    item: any;
-    state: string;
-  }> & { hasFocusableInside: (item: any) => boolean };
+  CellRenderer: React.FunctionComponent<any> & {
+    hasFocusableInside: (item: any) => boolean;
+  };
   preferredFocus: boolean;
   navigator: {
     push: (arg1: Record<any, any>) => void;

package/Components/Cell/__tests__/CellWIthFocusable.test.js

@@ -1,7 +1,7 @@
 import { View } from "react-native";
 import React from "react";
 import { act, render } from "@testing-library/react-native";
-import { CellWithFocusable } from "../CellWithFocusable";
+import { CellWithFocusable } from "../CellWithFocusable.tsx";
 
 import { focusManager } from "@applicaster/zapp-react-native-utils/appUtils/focusManager";
 
@@ -23,7 +23,9 @@ describe("CellWithFocusable", () => {
 
     const wrapper = renderWith(props);
 
-    expect(wrapper.UNSAFE_getByType("View").props.state).toBe("default");
+    const element = wrapper.getByTestId("cell-with-focusable-cell-renderer");
+
+    expect(element.props.state).toBe("default");
   });
 
   it("should render in default state", () => {
@@ -40,8 +42,9 @@ describe("CellWithFocusable", () => {
     focusManager.isGroupItemFocused = jest.fn(() => true);
 
     const wrapper = renderWith(props);
+    const element = wrapper.getByTestId("cell-with-focusable-cell-renderer");
 
-    expect(wrapper.UNSAFE_getByType("View").props.state).toBe("default");
+    expect(element.props.state).toBe("default");
   });
 
   it("should render in focused state", () => {
@@ -55,13 +58,17 @@ describe("CellWithFocusable", () => {
       scrollTo: jest.fn(),
     };
 
-    focusManager.isGroupItemFocused = jest.fn(() => true);
     const wrapper = renderWith(props);
 
+    const focusableGroupComponent = wrapper.getByTestId(
+      "cell-with-focusable-cell-renderer-focusable-group"
+    );
+
     act(() => {
-      focusManager.on.mock.calls[focusManager.on.mock.calls.length - 1][1]();
+      focusableGroupComponent.props.onFocus();
     });
 
-    expect(wrapper.UNSAFE_getByType("View").props.state).toBe("focused");
+    const element = wrapper.getByTestId("cell-with-focusable-cell-renderer");
+    expect(element.props.state).toBe("focused");
   });
 });

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

@@ -3,24 +3,24 @@
 exports[`CellRendererResolver renders correctly 1`] = `
 <View
   someProp={
-    Object {
-      "cellOptions": Object {},
-      "cellStyles": Object {
-        "ABCDE-123456": Object {
-          "configuration": Object {},
+    {
+      "cellOptions": {},
+      "cellStyles": {
+        "ABCDE-123456": {
+          "configuration": {},
           "plugin_identifier": "custom_renderer_plugin",
         },
-        "FGHIJ-123456": Object {
-          "configuration": Object {},
+        "FGHIJ-123456": {
+          "configuration": {},
           "plugin_identifier": "unknown_plugin",
         },
       },
-      "component": Object {
-        "styles": Object {
+      "component": {
+        "styles": {
           "cell_plugin_configuration_id": "ABCDE-123456",
         },
       },
-      "styles": Object {},
+      "styles": {},
     }
   }
 />
@@ -29,24 +29,24 @@ exports[`CellRendererResolver renders correctly 1`] = `
 exports[`CellRendererResolver with a default renderer plugin renders correctly 1`] = `
 <View
   someProp={
-    Object {
-      "cellOptions": Object {},
-      "cellStyles": Object {
-        "ABCDE-123456": Object {
-          "configuration": Object {},
+    {
+      "cellOptions": {},
+      "cellStyles": {
+        "ABCDE-123456": {
+          "configuration": {},
           "plugin_identifier": "custom_renderer_plugin",
         },
-        "FGHIJ-123456": Object {
-          "configuration": Object {},
+        "FGHIJ-123456": {
+          "configuration": {},
           "plugin_identifier": "unknown_plugin",
         },
       },
-      "component": Object {
-        "styles": Object {
+      "component": {
+        "styles": {
           "cell_plugin_configuration_id": "ABCDE-123456",
         },
       },
-      "styles": Object {},
+      "styles": {},
     }
   }
 />

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

@@ -2,9 +2,11 @@ import * as React from "react";
 import { View } from "react-native";
 import { shallow } from "enzyme";
 
-jest.mock("../../default-cell-renderer", () =>
-  jest.fn((prop) => <View whoAmI="default renderer" someProp={prop} />)
-);
+jest.mock("../../default-cell-renderer", () => {
+  const View = jest.requireActual("react-native").View;
+
+  return jest.fn((prop) => <View whoAmI="default renderer" someProp={prop} />);
+});
 
 const { CellRendererResolver } = require("../index");
 

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

@@ -5,22 +5,22 @@ exports[`ComponentResolver renders correctly 1`] = `
   value={null}
 >
   <Memo(ComponentResolver)
-    cellStyles={Object {}}
+    cellStyles={{}}
     component={
-      Object {
+      {
         "component_type": "some_component",
       }
     }
     components={
-      Object {
+      {
         "SomeComponent": [MockFunction],
       }
     }
     decorators={[MockFunction]}
     dispatch={[Function]}
-    plugins={Array []}
+    plugins={[]}
     store={
-      Object {
+      {
         "clearActions": [Function],
         "dispatch": [Function],
         "getActions": [Function],

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

@@ -4,19 +4,21 @@ import { shallow } from "enzyme";
 import { shallowToJson } from "enzyme-to-json";
 import configureStore from "redux-mock-store";
 
-const logger = {
+const mockLogger = {
   warning: jest.fn(),
 };
 
 jest.mock("../../../Helpers/logger", () => ({
   componentsLogger: {
-    addSubsystem: jest.fn(() => logger),
+    addSubsystem: jest.fn(() => mockLogger),
   },
 }));
 
-jest.mock("../../default-cell-renderer", () =>
-  jest.fn((prop) => <View whoAmI="default renderer" someProp={prop} />)
-);
+jest.mock("../../default-cell-renderer", () => {
+  const View = jest.requireActual("react-native").View;
+
+  return jest.fn((prop) => <View whoAmI="default renderer" someProp={prop} />);
+});
 
 const mock_rtl_flag = false;
 
@@ -48,7 +50,7 @@ function clearAllMocks() {
   SomeComponent.mockClear();
   decorators.mockClear();
   renderFunction.mockClear();
-  logger.warning.mockClear();
+  mockLogger.warning.mockClear();
 }
 
 describe("ComponentResolver", () => {
@@ -104,16 +106,16 @@ describe("ComponentResolverComponent", () => {
     expect(shallowToJson(wrapper)).toMatchSnapshot();
     expect(wrapper.isEmptyRender()).toBe(true);
 
-    expect(logger.warning).toHaveBeenCalledTimes(2);
+    expect(mockLogger.warning).toHaveBeenCalledTimes(2);
 
-    expect(logger.warning).toHaveBeenNthCalledWith(
+    expect(mockLogger.warning).toHaveBeenNthCalledWith(
       1,
       expect.objectContaining({
         message: "Could not resolve cell builder plugin",
       })
     );
 
-    expect(logger.warning).toHaveBeenNthCalledWith(
+    expect(mockLogger.warning).toHaveBeenNthCalledWith(
       2,
       expect.objectContaining({
         message: warningMessage,

package/Components/DisplayState/__tests__/__snapshots__/displayState.test.js.snap

@@ -1,7 +1,7 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
 exports[`DISPLAY_STATES matches the snapshot 1`] = `
-Object {
+{
   "CONTENT": "CONTENT",
   "CONTROLS": "CONTROLS",
   "DISCOVERY": "DISCOVERY",
@@ -9,7 +9,7 @@ Object {
 `;
 
 exports[`DisplayStateContext has the correct properties 1`] = `
-Object {
+{
   "Consumer": [MockFunction],
   "Provider": [MockFunction],
   "withConsumer": [MockFunction],

package/Components/Focusable/Focusable.tsx

@@ -1,5 +1,4 @@
 import * as React from "react";
-import * as R from "ramda";
 
 import { BaseFocusable } from "../BaseFocusable";
 import { focusManager } from "@applicaster/zapp-react-native-utils/appUtils/focusManager";
@@ -42,8 +41,6 @@ class Focusable extends BaseFocusable<Props> {
     this.resetLongPressTimeout = this.resetLongPressTimeout.bind(this);
     this.longPress = this.longPress.bind(this);
     this.press = this.press.bind(this);
-    this.focus = this.focus.bind(this);
-    this.blur = this.blur.bind(this);
   }
 
   /**
@@ -55,37 +52,6 @@ class Focusable extends BaseFocusable<Props> {
     return this.preferredFocus();
   }
 
-  /**
-   * Sets the focus on this item. Will trigger sequentially a sequence of
-   * functions (willReceiveFocus, focus, hasReceivedFocus). If these functions (defined in the Focusable
-   * Item underlying component) return promises, execution will wait before it proceeds to the next. This
-   * is useful for triggering sequential operations that specifically require to fully run before or after
-   * focus is actually set on that item.
-   * @param {string} scrollDirection string representation of the direction of the navigation which landed
-   * to this item being focused
-   */
-  setFocus(scrollDirection) {
-    const focusMethods = [
-      this.willReceiveFocus,
-      this.focus,
-      this.hasReceivedFocus,
-    ];
-
-    const self = this;
-
-    return R.reduce(
-      (sequence, method) => {
-        return sequence
-          .then(() => method.apply(self, [scrollDirection]))
-          .catch((e) => {
-            throw e;
-          });
-      },
-      Promise.resolve(),
-      focusMethods
-    );
-  }
-
   startLongPressTimeout() {
     this.longPressTimeout = setTimeout(() => {
       this.longPress(null);
@@ -102,26 +68,6 @@ class Focusable extends BaseFocusable<Props> {
     }
   }
 
-  /**
-   * will invoke the underlying component's focus method
-   * @param {Object} scrollDirection
-   * @returns {Promise}
-   */
-  focus(scrollDirection) {
-    return this.onFocus(this, scrollDirection); // invokeComponentMethod(this, "onFocus", scrollDirection);
-  }
-
-  /**
-   * will invoke the underlying component's blur method
-   * @param {Object} scrollDirection
-   * @returns {Promise}
-   */
-  blur(
-    scrollDirection?: FocusManager.Web.Direction | FocusManager.IOS.Direction
-  ) {
-    return this.onBlur(this, scrollDirection);
-  }
-
   /**
    * will invoke the underlying component's press method
    * @param {Object} keyEvent

package/Components/Focusable/FocusableTvOS.tsx

@@ -90,7 +90,7 @@ export class Focusable extends BaseFocusable<Props> {
     onBlur(nativeEvent);
   }
 
-  setFocus(direction, callback) {
+  setFocus(_direction, callback) {
     const focusMethods = [
       { method: this.willReceiveFocus },
       { method: this.focus, args: [callback] },

package/Components/Focusable/Touchable.tsx

@@ -1,25 +1,24 @@
 import * as React from "react";
 
-type Props =
-  | {
-      id: string;
-      children: React.ReactNode;
-      onPress?: (ref: FocusManager.TouchableRef) => void;
-      onPressIn?: (ref: FocusManager.TouchableRef) => void;
-      onPressOut?: (ref: FocusManager.TouchableRef) => void;
-      onLongPress?: (ref: FocusManager.TouchableRef) => void;
-      onFocus?: (
-        ref: FocusManager.TouchableRef,
-        options: FocusManager.Android.CallbackOptions
-      ) => void;
-      onBlur?: (
-        ref: FocusManager.TouchableRef,
-        options: FocusManager.Android.CallbackOptions
-      ) => void;
-
-      disableFocus?: boolean;
-      blockFocus?: boolean;
-    } & Partial<ParentFocus>;
+type Props = {
+  id: string;
+  children: React.ReactNode;
+  onPress?: (ref: FocusManager.TouchableRef) => void;
+  onPressIn?: (ref: FocusManager.TouchableRef) => void;
+  onPressOut?: (ref: FocusManager.TouchableRef) => void;
+  onLongPress?: (ref: FocusManager.TouchableRef) => void;
+  onFocus?: (
+    ref: FocusManager.TouchableRef,
+    options: FocusManager.Android.CallbackOptions
+  ) => void;
+  onBlur?: (
+    ref: FocusManager.TouchableRef,
+    options: FocusManager.Android.CallbackOptions
+  ) => void;
+
+  disableFocus?: boolean;
+  blockFocus?: boolean;
+} & Partial<ParentFocus>;
 
 export class Touchable extends React.Component<Props> {
   onPress(focusableRef: FocusManager.TouchableRef): void {

package/Components/FocusableList/index.tsx

@@ -87,7 +87,6 @@ function FocusableListComponent<ItemT>(props: Props<ItemT>, ref) {
     initialFocusDirection = "down",
     data = [],
     // eslint-disable-next-line unused-imports/no-unused-vars
-    onAllComponentsLoaded, // TODO: re-implement it
     omitPropsPropagation = [],
   } = props;
 

package/Components/FocusableScrollView/index.tsx

@@ -11,13 +11,6 @@ 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;
@@ -39,27 +32,17 @@ export type Props = ScrollViewProps & {
   initialFocusDirection?: FocusManager.Android.FocusNavigationDirections;
   onAllComponentsLoaded?: () => void;
   omitPropsPropagation?: Array<keyof FlatListProps<any>>;
-  renderItem: FocusableScrollViewRenderItem;
+  renderItem: (info: {
+    item: ZappUIComponent;
+    index: number;
+    focused: boolean;
+    parentFocus: ParentFocus;
+  }) => React.ReactElement;
 } & ParentFocus;
 
 type State = boolean[];
 type Action = { index?: number; isFocusable: boolean; type?: string };
 
-const unwrapArray = (maybeArray) =>
-  Array.isArray(maybeArray) ? maybeArray[0] : maybeArray;
-
-function getEntry<T>(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
@@ -90,7 +73,7 @@ const extendScrollViewRef = (_ref, childCompsMeasurementsMap) => {
   };
 
   _ref.scrollToIndex = (params) => {
-    const { index, viewOffset = 0 } = params;
+    const { index, viewOffset } = params;
 
     const itemByIndex = R.find(R.propEq("index", index))(
       R.values(childCompsMeasurementsMap)
@@ -146,11 +129,8 @@ function FocusableScrollViewComponent(props: Props, ref) {
   );
 
   const getFocusableEntryId = React.useCallback(
-    (_entry: ZappEntry | null, index?: number) => {
-      const entry: { id?: string } = getEntry(
-        R.isNil(index) ? _entry : data,
-        index
-      );
+    (_entry: ZappEntry, index?: number) => {
+      const entry = R.isNil(index) ? _entry : data[index];
 
       return entry ? `${props.id}--${entry?.id}` : undefined;
     },
@@ -293,18 +273,11 @@ function FocusableScrollViewComponent(props: Props, ref) {
   const renderItem = React.useCallback(
     (item, index) => {
       const renderArgs = { item, index };
-
-      const id = getFocusableEntryId(
-        Array.isArray(item) ? item[0] : item,
-        index
-      );
-
-      const nextFocus = getNextFocus(index);
+      const id = `${props.id}--${renderArgs?.item?.id}`;
+      const nextFocus = getNextFocus(renderArgs?.index);
 
       const onItemLayout = (event) => {
-        childCompsMeasurementsMap.current[
-          Array.isArray(item) ? index : item.id
-        ] = {
+        childCompsMeasurementsMap.current[item.id] = {
           index,
           layout: event.nativeEvent.layout,
         };