@applicaster/zapp-react-native-ui-components 12.0.0-alpha.4433422595 → 12.0.0-alpha.4440903139

package/Components/BaseFocusable/index.tsx

@@ -66,14 +66,14 @@ export class BaseFocusable<
     const { initialFocus } = this.props;
 
     if (initialFocus) {
-      focusManager.setupInitialFocus(this.getId());
+      focusManager.setFocus(this.getId());
     }
   }
 
   getId(props?: { id: string; groupId: string }) {
-    const { id, groupId = null } = props || this.props;
+    const { id } = props || this.props;
 
-    return groupId ? `groupId:${groupId}___${id}` : id;
+    return id;
   }
 
   getRect() {

package/Components/Cell/Cell.tsx

@@ -1,5 +1,5 @@
 import * as React from "react";
-import * as R from "ramda";
+import { join, merge, path } from "ramda";
 import { View } from "react-native";
 
 import { Focusable } from "@applicaster/zapp-react-native-ui-components/Components/Focusable";
@@ -11,6 +11,7 @@ import { noop } from "@applicaster/zapp-react-native-utils/functionUtils";
 
 import { CellWithFocusable } from "./CellWithFocusable";
 import { BaseFocusable } from "../BaseFocusable";
+import { AccessibilityManager } from "@applicaster/zapp-react-native-utils/appUtils/accessibilityManager";
 
 type Props = {
   item: {
@@ -66,6 +67,10 @@ type Props = {
   behavior: Behavior;
 };
 
+type State = {
+  hasFocusableInside: boolean;
+};
+
 const baseCellStyles = {
   height: "100%",
   display: "flex",
@@ -77,7 +82,7 @@ const touchableStyles = {
   height: "100%",
 } as const;
 
-export class CellComponent extends React.Component<Props> {
+export class CellComponent extends React.Component<Props, State> {
   constructor(props) {
     super(props);
     this.onPress = this.onPress.bind(this);
@@ -87,6 +92,10 @@ export class CellComponent extends React.Component<Props> {
     this.hasReceivedFocus = this.hasReceivedFocus.bind(this);
     this.scrollVertically = this.scrollVertically.bind(this);
     this.scrollToIndex = this.scrollToIndex.bind(this);
+
+    this.state = {
+      hasFocusableInside: props.CellRenderer.hasFocusableInside?.(props.item),
+    };
   }
 
   setScreenLayout(componentAnchorPointY, screenLayout) {
@@ -105,8 +114,8 @@ export class CellComponent extends React.Component<Props> {
       onPress(item, index);
     } else {
       const { item, navigator, component, appData } = this.props;
-      const itemTargetScreen = R.path(["screen_type"], item);
-      const componentTargetScreen = R.path(["data", "target"], component);
+      const itemTargetScreen = path(["screen_type"], item);
+      const componentTargetScreen = path(["data", "target"], component);
       const itemType = getItemType(item, appData?.layoutVersion);
 
       sendSelectCellEvent(item, component, item.title, index);
@@ -116,7 +125,7 @@ export class CellComponent extends React.Component<Props> {
         componentTargetScreen &&
         !itemTargetScreen
       ) {
-        navigator.push(R.merge(item, { screen_type: componentTargetScreen }));
+        navigator.push(merge(item, { screen_type: componentTargetScreen }));
 
         return;
       }
@@ -139,6 +148,10 @@ export class CellComponent extends React.Component<Props> {
         shouldScrollVertically?.(mouse, focusable, id, title)
       ) {
         this.scrollVertically(focusable);
+
+        const accessibilityManager = AccessibilityManager.getInstance();
+        // Text from DSP should be localized already
+        accessibilityManager.readText({ text: title });
       }
     }
   }
@@ -187,6 +200,16 @@ export class CellComponent extends React.Component<Props> {
     return !isFocusable ? false : focused || focusableFocused;
   }
 
+  componentDidUpdate(prevProps: Readonly<Props>) {
+    if (prevProps.item !== this.props.item) {
+      this.setState({
+        hasFocusableInside: this.props.CellRenderer.hasFocusableInside?.(
+          this.props.item
+        ),
+      });
+    }
+  }
+
   render() {
     const {
       item,
@@ -207,11 +230,7 @@ export class CellComponent extends React.Component<Props> {
 
     const { id } = item;
 
-    const focusableId = R.join("-", [
-      `componentId:${component?.id}`,
-      `id:${id}`,
-      `index:${index}`,
-    ]);
+    const focusableId = join("-", [component?.id, id, index]);
 
     const handleFocus = (focusable, mouse) => {
       const focusFn = onFocus || noop;
@@ -219,9 +238,7 @@ export class CellComponent extends React.Component<Props> {
       this.onFocus(focusable, mouse);
     };
 
-    const hasFocusableInside = CellRenderer.hasFocusableInside?.(item);
-
-    if (hasFocusableInside) {
+    if (this.state.hasFocusableInside) {
       return (
         <CellWithFocusable
           CellRenderer={CellRenderer}

package/Components/Cell/CellWithFocusable.tsx

@@ -3,15 +3,25 @@ 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 = (groupId: string, id: string) => {
+const useCellFocusedState = (
+  skipFocusManagerRegistration: boolean,
+  groupId: string,
+  id: string
+) => {
   const [currentCellFocused, setCurrentCellFocused] = React.useState(false);
 
   React.useEffect(() => {
-    const isGroupItemFocused = () =>
-      setCurrentCellFocused(focusManager.isGroupItemFocused(groupId, id));
+    const isGroupItemFocused = () => {
+      if (!skipFocusManagerRegistration) {
+        const isFocused = focusManager.isGroupItemFocused(groupId, id);
+        setCurrentCellFocused(isFocused);
+      }
+    };
 
     const handler = () => {
       // tvOS hack for properly checking focus
@@ -29,7 +39,7 @@ const useCellFocusedState = (groupId: string, id: string) => {
     return () => {
       focusManager.removeHandler(FOCUS_EVENTS.FOCUS, handler);
     };
-  }, [groupId]);
+  }, [groupId, skipFocusManagerRegistration]);
 
   return currentCellFocused;
 };
@@ -46,7 +56,7 @@ type Props = {
   skipFocusManagerRegistration?: boolean;
   isFocusable?: boolean;
   behavior: Behavior;
-  selected?: boolean;
+  focused?: boolean;
 };
 
 export function CellWithFocusable(props: Props) {
@@ -62,16 +72,19 @@ export function CellWithFocusable(props: Props) {
     skipFocusManagerRegistration,
     isFocusable,
     behavior,
-    selected,
+    focused,
   } = props;
 
-  const isFocused = useCellFocusedState(groupId, id);
+  const isFocused = useCellFocusedState(
+    skipFocusManagerRegistration,
+    groupId,
+    id
+  );
 
   const state = useCellState({
     id: item.id,
     behavior,
-    focused: isFocused,
-    selected,
+    focused: isFocused || toBooleanWithDefaultFalse(focused),
   });
 
   const [focusedButtonId, setFocusedButtonId] = React.useState(undefined);
@@ -102,6 +115,7 @@ export function CellWithFocusable(props: Props) {
       preferredFocus={preferredFocus}
       skipFocusManagerRegistration={skipFocusManagerRegistration}
       isFocusable={isFocusable}
+      focused={focused}
     />
   );
 }

package/Components/Cell/TvOSCellComponent.tsx

@@ -226,13 +226,7 @@ export class TvOSCellComponent extends React.Component<Props, State> {
 
   hasReceivedFocus() {}
 
-  scrollTo(index) {
-    // Workaround for HL autoscroll/autoloop feature, we scroll manually on tvOS.
-    // Should be removed after refactoring autoscroll/autoloop feature
-    if (this.props.component?.component_type !== "horizontal_list_qb") {
-      this.props?.scrollToIndex?.(index);
-    }
-  }
+  scrollTo() {}
 
   render() {
     const {
@@ -279,7 +273,9 @@ export class TvOSCellComponent extends React.Component<Props, State> {
             index={index}
             scrollTo={this.scrollTo}
             preferredFocus={preferredFocus}
+            focused={this.props.focused}
             behavior={behavior}
+            isFocusable={isFocusable}
           />
         </View>
       );

package/Components/Focusable/Focusable.tsx

@@ -4,6 +4,7 @@ import * as R from "ramda";
 import { BaseFocusable } from "../BaseFocusable";
 import { focusManager } from "@applicaster/zapp-react-native-utils/appUtils/focusManager";
 import { LONG_KEY_PRESS_TIMEOUT } from "@applicaster/quick-brick-core/const";
+import { withFocusableContext } from "../../Contexts/FocusableGroupContext/withFocusableContext";
 
 type Props = {
   initialFocus?: boolean;
@@ -23,7 +24,7 @@ type Props = {
   style?: React.CSSProperties;
 };
 
-export class Focusable extends BaseFocusable<Props> {
+class Focusable extends BaseFocusable<Props> {
   isGroup: boolean;
   mouse: boolean;
   longPressTimeout = null;
@@ -198,3 +199,7 @@ export class Focusable extends BaseFocusable<Props> {
     );
   }
 }
+
+const FocusableWithFocusableContext = withFocusableContext(Focusable);
+
+export { FocusableWithFocusableContext as Focusable };

package/Components/Focusable/__tests__/index.android.test.tsx

@@ -0,0 +1,72 @@
+import React from "react";
+import { render, act } from "@testing-library/react-native";
+import { Touchable } from "../../Touchable";
+
+const mockUseIsRTL = jest.fn();
+
+jest.mock("@applicaster/zapp-react-native-utils/localizationUtils", () => ({
+  useIsRTL: mockUseIsRTL,
+}));
+
+const mockUseFocusManager = jest.fn();
+
+jest.mock("@applicaster/zapp-react-native-utils/focusManager", () => ({
+  useFocusManager: mockUseFocusManager,
+}));
+
+const mockUsePrevious = jest.fn();
+
+jest.mock("@applicaster/zapp-react-native-utils/reactHooks/utils", () => ({
+  usePrevious: mockUsePrevious,
+}));
+
+const { Focusable } = require("../index.android");
+
+describe("Focusable", () => {
+  const mockFocusManager = {
+    isFocused: jest.fn(),
+    onDisableFocusChange: jest.fn(),
+    registerFocusable: jest.fn(),
+    focusedId: "test-id",
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockUseIsRTL.mockReturnValue(false);
+    mockUseFocusManager.mockReturnValue(mockFocusManager);
+    mockUsePrevious.mockReturnValue(false);
+  });
+
+  it("updates disableFocus state when disableFocus prop changes", () => {
+    const { rerender } = render(
+      <Focusable id="test-id" disableFocus={false}>
+        <Touchable testID="touchable" />
+      </Focusable>
+    );
+
+    rerender(
+      <Focusable id="test-id" disableFocus={true}>
+        <Touchable testID="touchable" />
+      </Focusable>
+    );
+
+    expect(mockFocusManager.onDisableFocusChange).toHaveBeenCalledWith(
+      "test-id"
+    );
+  });
+
+  it("calls focusManager.registerFocusable on mount and unregisters on unmount", () => {
+    const unregister = jest.fn();
+    mockFocusManager.registerFocusable.mockReturnValue(unregister);
+
+    const { unmount } = render(
+      <Focusable id="test-id">
+        <Touchable testID="touchable" />
+      </Focusable>
+    );
+
+    expect(mockFocusManager.registerFocusable).toHaveBeenCalled();
+    act(() => unmount());
+    expect(unregister).toHaveBeenCalled();
+  });
+});

package/Components/Focusable/index.android.tsx

@@ -128,7 +128,10 @@ function FocusableComponent(props: Props, forwardedRef) {
 
   const _onBlur = React.useCallback(
     (ref, options = {}) => {
-      setFocused(false);
+      if (ref.props.id !== focusManager.focusedId) {
+        setFocused(false);
+      }
+
       onBlur?.(ref, options);
     },
     [onBlur]
@@ -148,15 +151,14 @@ function FocusableComponent(props: Props, forwardedRef) {
     [isRTL, nextFocusDown, nextFocusUp, nextFocusLeft, nextFocusRight]
   );
 
-  const contextState = React.useMemo(
-    () => ({
+  const contextState = React.useMemo(() => {
+    return {
       focused,
       ...parentFocus,
       ref: touchableRef,
       setIsFocusable,
-    }),
-    [parentFocus, focused]
-  );
+    };
+  }, [parentFocus, focused]);
 
   return (
     <Touchable
@@ -173,9 +175,13 @@ function FocusableComponent(props: Props, forwardedRef) {
       {...parentFocus}
     >
       <FocusableContext.Provider value={contextState}>
-        {typeof children === "function"
-          ? children(focused, parentFocus, touchableRef)
-          : children}
+        {React.useMemo(
+          () =>
+            typeof children === "function"
+              ? children(focused, parentFocus, touchableRef)
+              : children,
+          [children, focused, parentFocus]
+        )}
       </FocusableContext.Provider>
     </Touchable>
   );

package/Components/FocusableGroup/index.tsx

@@ -1,6 +1,8 @@
 import * as React from "react";
 
 import { BaseFocusable } from "../BaseFocusable";
+import { FocusableGroupContextProvider } from "../../Contexts/FocusableGroupContext";
+import { withFocusableContext } from "../../Contexts/FocusableGroupContext/withFocusableContext";
 
 type Props = {
   testID?: string;
@@ -29,7 +31,7 @@ type Props = {
   excludeFromFocusSearching?: boolean;
 };
 
-export class FocusableGroup extends BaseFocusable<Props> {
+class FocusableGroup extends BaseFocusable<Props> {
   constructor(props) {
     super(props);
     this.isGroup = true;
@@ -82,8 +84,14 @@ export class FocusableGroup extends BaseFocusable<Props> {
         style={style}
         ref={this.ref}
       >
-        {children}
+        <FocusableGroupContextProvider id={id}>
+          {children}
+        </FocusableGroupContextProvider>
       </div>
     );
   }
 }
+
+const FocusableGroupWithFocusableContext = withFocusableContext(FocusableGroup);
+
+export { FocusableGroupWithFocusableContext as FocusableGroup };

package/Components/FocusableList/FocusableChild.ts

@@ -1,7 +1,6 @@
 import * as React from "react";
 import { isEqual } from "@applicaster/zapp-react-native-utils/equalUtils";
 import { useFocusable } from "../Focusable/index.android";
-import { useCellState } from "./hooks/useCellState.android";
 
 /**
  * returns parent focus from prop or from context
@@ -30,15 +29,14 @@ const useParentFocus = (
   );
 
 function FocusableChildComponent(props) {
-  const { setIsFocusable, ...focusableContext } = useFocusable();
+  const { setIsFocusable, focused, ...focusableContext } = useFocusable();
+
   const parentFocus = useParentFocus(props, focusableContext);
 
   const onLoadFailed = React.useCallback(() => {
     setIsFocusable(false);
   }, []);
 
-  const focused = useCellState(props.id);
-
   return props.renderItem({
     ...props,
     focused,

package/Components/FocusableList/index.tsx

@@ -88,6 +88,7 @@ function FocusableListComponent<ItemT>(props: Props<ItemT>, ref) {
     data = [],
     // eslint-disable-next-line unused-imports/no-unused-vars
     onAllComponentsLoaded, // TODO: re-implement it
+    omitPropsPropagation = [],
   } = props;
 
   useCheckItemIdsForUnique({ componentId: props.id, items: data });
@@ -252,9 +253,9 @@ function FocusableListComponent<ItemT>(props: Props<ItemT>, ref) {
     ]
   );
 
-  const flatListProps = React.useMemo(
-    () =>
-      R.omit([
+  const getFlatListProps = React.useCallback(
+    R.omit(
+      [
         "onListElementFocus",
         "onListElementPress",
         "onListElementPressOut",
@@ -267,17 +268,17 @@ function FocusableListComponent<ItemT>(props: Props<ItemT>, ref) {
         "focusableItemProps",
         "renderItem",
         "extraChildrenData",
-        "extraData",
-        "keyExtractor",
         "onAllComponentsLoaded",
         "focused",
         "id",
         "initialFocusDirection",
         "withStateMemory",
         "useSequentialLoading",
-        ...(props.omitPropsPropagation || []),
-      ])(props),
-    [props]
+        ...omitPropsPropagation,
+      ],
+      R.__
+    ),
+    [omitPropsPropagation]
   );
 
   const onEndReached = React.useCallback(
@@ -289,7 +290,7 @@ function FocusableListComponent<ItemT>(props: Props<ItemT>, ref) {
 
   const initialNumToRender = toFiniteNumberWithDefault(
     10,
-    flatListProps.initialNumToRender
+    props.initialNumToRender
   );
 
   return (
@@ -298,12 +299,10 @@ function FocusableListComponent<ItemT>(props: Props<ItemT>, ref) {
       <FlatList
         focusable={false}
         scrollEnabled={false}
-        extraData={props.extraData}
         ref={ref}
-        {...flatListProps}
+        {...getFlatListProps(props)}
         renderItem={renderItem}
         onEndReached={onEndReached}
-        keyExtractor={props.keyExtractor}
         initialNumToRender={initialNumToRender}
       />
     </ChildrenFocusDeactivatorView>

package/Components/FocusableScrollView/index.tsx

@@ -284,7 +284,7 @@ function FocusableScrollViewComponent(props: Props, ref) {
       };
 
       return (
-        <View onLayout={onItemLayout}>
+        <View key={id} onLayout={onItemLayout}>
           <Focusable
             {...nextFocus}
             onFocus={(element, direction) =>

package/Components/FreezeWithCallback/Freeze.tsx

@@ -0,0 +1,31 @@
+import { usePrevious } from "@applicaster/zapp-react-native-utils/reactHooks/utils";
+import React, { Suspense, useEffect } from "react";
+import { Suspender } from "./Suspender";
+
+interface Props {
+  freeze: boolean;
+  children: React.ReactNode;
+  placeholder?: React.ReactNode;
+  onRelease?: () => void;
+}
+
+export function Freeze({
+  freeze,
+  children,
+  placeholder = null,
+  onRelease,
+}: Props) {
+  const prevFreeze = usePrevious(freeze);
+
+  useEffect(() => {
+    if (prevFreeze && !freeze && onRelease) {
+      onRelease();
+    }
+  }, [freeze, onRelease, prevFreeze]);
+
+  return (
+    <Suspense fallback={placeholder}>
+      <Suspender freeze={freeze}>{children}</Suspender>
+    </Suspense>
+  );
+}

package/Components/FreezeWithCallback/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Software Mansion
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/Components/FreezeWithCallback/Suspender.tsx

@@ -0,0 +1,17 @@
+import React, { Fragment } from "react";
+
+const infiniteThenable = { then() {} };
+
+export const Suspender = ({
+  freeze,
+  children,
+}: {
+  freeze: boolean;
+  children: React.ReactNode;
+}) => {
+  if (freeze) {
+    throw infiniteThenable;
+  }
+
+  return <Fragment>{children}</Fragment>;
+};