@applicaster/zapp-react-native-ui-components 13.0.0-alpha.7222542422 → 13.0.0-alpha.7223143213

package/Components/Cell/CellWithFocusable.tsx

@@ -1,48 +1,10 @@
 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;
@@ -75,14 +37,10 @@ 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,
+    item,
     behavior,
     focused: isFocused || toBooleanWithDefaultFalse(focused),
   });
@@ -96,26 +54,53 @@ 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}
+      shouldUsePreferredFocus
+      onFocus={onGroupFocus}
+      onBlur={onGroupBlur}
       skipFocusManagerRegistration={skipFocusManagerRegistration}
-      isFocusable={isFocusable}
-      focused={focused}
-    />
+    >
+      <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/__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__/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/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

@@ -1,13 +1,13 @@
 import React, { useMemo } from "react";
 import * as R from "ramda";
 import {
-  View,
+  ImageStyle,
   StyleSheet,
   Text,
-  ViewStyle,
-  TextStyle,
-  ImageStyle,
   TextProps,
+  TextStyle,
+  View,
+  ViewStyle,
 } from "react-native";
 import { defaultAsset } from "./defaultAsset";
 import { platformSelect } from "@applicaster/zapp-react-native-utils/reactUtils";
@@ -150,13 +150,13 @@ export function ErrorScreen(props: Props) {
   return (
     <View style={[baseStyles.container, styles.screen]}>
       <View style={[baseStyles.container, styles.component]}>
-        {assetEnabled && (
+        {assetEnabled ? (
           <Image
             fadeDuration={0}
             source={{ uri: asset }}
             style={styles.asset}
           />
-        )}
+        ) : null}
         <Text style={styles.title} {...titleProps}>
           {title}
         </Text>

package/Components/Focusable/Focusable.tsx

@@ -1,3 +1,4 @@
+/* eslint-disable react/no-unknown-property */
 import * as React from "react";
 
 import { BaseFocusable } from "../BaseFocusable";

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/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) {