@applicaster/zapp-react-native-ui-components 12.0.0-rc.99 → 13.0.0-alpha.2322412833

package/Components/Cell/Cell.tsx

@@ -1,5 +1,5 @@
 import * as React from "react";
-import { join, path, merge } from "ramda";
+import { join, merge, path } from "ramda";
 import { View } from "react-native";
 
 import { Focusable } from "@applicaster/zapp-react-native-ui-components/Components/Focusable";
@@ -14,10 +14,7 @@ import { BaseFocusable } from "../BaseFocusable";
 import { AccessibilityManager } from "@applicaster/zapp-react-native-utils/appUtils/accessibilityManager";
 
 type Props = {
-  item: {
-    id: string;
-    title: string;
-  };
+  item: ZappEntry;
   index: number;
   shouldScrollHorizontally: (arg1: [any]) => boolean | null | undefined;
   shouldScrollVertically: (...args: any) => boolean | null | undefined;
@@ -33,10 +30,9 @@ type Props = {
     id: string;
   };
   selected?: boolean;
-  CellRenderer: React.ComponentType<{
-    item: any;
-    state: string;
-  }> & { hasFocusableInside: (item: Record<string, string>) => boolean };
+  CellRenderer: React.FunctionComponent<any> & {
+    hasFocusableInside: (item: ZappEntry) => boolean;
+  };
   preferredFocus: boolean;
   navigator: {
     push: (arg1: Record<any, any>) => void;
@@ -67,6 +63,10 @@ type Props = {
   behavior: Behavior;
 };
 
+type State = {
+  hasFocusableInside: boolean;
+};
+
 const baseCellStyles = {
   height: "100%",
   display: "flex",
@@ -78,7 +78,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);
@@ -88,6 +88,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) {
@@ -140,10 +144,6 @@ 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 });
       }
     }
   }
@@ -192,6 +192,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,
@@ -220,9 +230,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}
@@ -260,13 +268,20 @@ export class CellComponent extends React.Component<Props> {
           skipFocusManagerRegistration={skipFocusManagerRegistration}
         >
           {(focused, event) => {
+            const isFocused = this.isCellFocused(focused);
+
+            if (isFocused) {
+              const accessibilityManager = AccessibilityManager.getInstance();
+              accessibilityManager.readText({ text: String(item.title) });
+            }
+
             return (
               <FocusableCell
                 {...{
                   index,
                   CellRenderer,
                   item,
-                  focused: this.isCellFocused(focused),
+                  focused: isFocused,
                   scrollTo: this.scrollToIndex(event),
                   behavior,
                 }}

package/Components/Cell/CellWithFocusable.tsx

@@ -46,7 +46,7 @@ const useCellFocusedState = (
 
 type Props = {
   item: ZappEntry;
-  CellRenderer: React.ComponentType<{ item: Object; state: string }>;
+  CellRenderer: React.FunctionComponent<any>;
   id: string;
   groupId: string;
   onFocus: Function;

package/Components/Cell/TvOSCellComponent.tsx

@@ -36,10 +36,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/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/FocusableList/FocusableChild.ts

@@ -31,14 +31,14 @@ const useParentFocus = (
 
 function FocusableChildComponent(props) {
   const { setIsFocusable, ...focusableContext } = useFocusable();
+  const focused = useCellState(props.id);
+
   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>;
+};

package/Components/FreezeWithCallback/__tests__/index.test.tsx

@@ -0,0 +1,170 @@
+import React, { Dispatch, useEffect, useState } from "react";
+import {
+  act,
+  create,
+  ReactTestRenderer,
+  ReactTestRendererJSON,
+} from "react-test-renderer";
+import { FreezeWithCallback } from "../index";
+
+const SimpleContent = () => <div />;
+
+interface InnerProps {
+  value: number;
+}
+// eslint-disable-next-line unused-imports/no-unused-vars
+const Inner = ({ value }: InnerProps) => <div />;
+
+interface TestSubscriber {
+  renderCount: number;
+  subscription: Dispatch<number>;
+}
+
+function createSubscriberComponent(): [React.FC, TestSubscriber] {
+  const testState: TestSubscriber = {
+    renderCount: 0,
+    subscription: () => {},
+  };
+
+  const Subscriber: React.FC = () => {
+    const [value, setValue] = useState(0);
+
+    useEffect(() => {
+      testState.subscription = setValue;
+    }, []);
+
+    testState.renderCount += 1;
+
+    return <Inner value={value} />;
+  };
+
+  return [Subscriber, testState];
+}
+
+interface ContainerProps {
+  freeze: boolean;
+  children: React.ReactNode;
+}
+
+const Container = ({ freeze, children }: ContainerProps) => (
+  <FreezeWithCallback freeze={freeze}>{children}</FreezeWithCallback>
+);
+
+function setupTest(initialFreeze: boolean = false) {
+  let testRenderer: ReactTestRenderer | undefined;
+  const [Subscriber, subscriberState] = createSubscriberComponent();
+
+  act(() => {
+    testRenderer = create(
+      <Container freeze={initialFreeze}>
+        <Subscriber />
+      </Container>
+    );
+  });
+
+  return {
+    testRenderer,
+    testInstance: testRenderer?.root,
+    subscriberState,
+    updateFreeze: (freeze: boolean) => {
+      act(() =>
+        testRenderer?.update(
+          <Container freeze={freeze}>
+            <Subscriber />
+          </Container>
+        )
+      );
+    },
+  };
+}
+
+describe("FreezeWithCallback", () => {
+  test("Renders stuff not frozen", () => {
+    const testRenderer = create(
+      <Container freeze={false}>
+        <SimpleContent />
+      </Container>
+    );
+
+    expect(testRenderer.root.findByType(SimpleContent)).toBeTruthy();
+  });
+
+  test("Does not render stuff when frozen", () => {
+    const testRenderer = create(
+      <Container freeze>
+        <SimpleContent />
+      </Container>
+    );
+
+    expect(testRenderer.root.findAllByType(SimpleContent)).toHaveLength(0);
+  });
+
+  test("Stuff is gone after freeze", () => {
+    const testRenderer = create(
+      <Container freeze={false}>
+        <SimpleContent />
+      </Container>
+    );
+
+    expect(testRenderer.root.findByType(SimpleContent)).toBeTruthy();
+
+    act(() =>
+      testRenderer.update(
+        <Container freeze>
+          <SimpleContent />
+        </Container>
+      )
+    );
+
+    expect(testRenderer.toJSON()).toBe(null);
+  });
+
+  test("Updates work when not frozen", () => {
+    const { testInstance, subscriberState } = setupTest();
+
+    expect(testInstance?.findByType(Inner).props.value).toEqual(0);
+    act(() => subscriberState.subscription(1));
+    expect(testInstance?.findByType(Inner).props.value).toEqual(1);
+    expect(subscriberState.renderCount).toBe(2);
+  });
+
+  test("Updates does not propagate when frozen", () => {
+    const { testInstance, subscriberState, updateFreeze } = setupTest();
+
+    expect(testInstance?.findByType(Inner).props.value).toEqual(0);
+    updateFreeze(true);
+    act(() => subscriberState.subscription(1));
+    expect(testInstance?.findByType(Inner).props.value).toEqual(0);
+    expect(subscriberState.renderCount).toBe(1);
+  });
+
+  test("State persists after defrost", () => {
+    const { testInstance, subscriberState, updateFreeze, testRenderer } =
+      setupTest();
+
+    expect(testInstance?.findByType(Inner).props.value).toEqual(0);
+    act(() => subscriberState.subscription(1));
+    expect(testInstance?.findByType(Inner).props.value).toEqual(1);
+
+    updateFreeze(true);
+    expect(testRenderer?.toJSON()).toBe(null);
+
+    updateFreeze(false);
+    expect((testRenderer?.toJSON() as ReactTestRendererJSON).type).toBe("div");
+    expect(testInstance?.findByType(Inner).props.value).toEqual(1);
+  });
+
+  test("Update propagate after defrost", () => {
+    const { testInstance, subscriberState, updateFreeze } = setupTest();
+
+    updateFreeze(true);
+    act(() => subscriberState.subscription(1));
+    act(() => subscriberState.subscription(2));
+    act(() => subscriberState.subscription(3));
+    expect(testInstance?.findByType(Inner).props.value).toEqual(0);
+
+    updateFreeze(false);
+    expect(testInstance?.findByType(Inner).props.value).toEqual(3);
+    expect(subscriberState.renderCount).toBe(2);
+  });
+});

package/Components/FreezeWithCallback/index.tsx

@@ -0,0 +1,3 @@
+import { Freeze } from "./Freeze";
+
+export const FreezeWithCallback = Freeze;

package/Components/Image/Image.android.tsx

@@ -8,5 +8,5 @@ import { useImageSource } from "./utils";
 export const QBImage = (props: FastImageProps) => {
   const source = useImageSource(props.source);
 
-  return <FastImage {...props} source={source} />;
+  return <FastImage useLastImageAsDefaultSource {...props} source={source} />;
 };

package/Components/MasterCell/DefaultComponents/ActionButton.tsx

@@ -66,20 +66,24 @@ export function ActionButton(props: Props) {
   );
 
   useEffect(() => {
-    if (actionDisabled || !actionContext) return;
-
-    setActionState(actionContext.initialEntryState(item));
-  }, [actionDisabled, item?.id, actionContext]);
+    if (!((actionDisabled || !actionContext) && actionState !== null)) {
+      setActionState(actionContext.initialEntryState(item));
+    }
+  }, [actionDisabled, item?.id, actionContext, action]);
 
   const onPress = useCallback(() => {
     actionContext.invokeAction(item, {
-      updateState: setActionState,
+      updateState: (state) => {
+        setActionState(state);
+      },
     });
-  }, [actionState, actionContext?.state, setActionState, item?.id]);
+  }, [actionState, actionContext?.state, item?.id]);
 
   useEffect(() => {
     if (typeof actionContext?.addListener === "function") {
-      return actionContext?.addListener(item.id as string, setActionState);
+      return actionContext?.addListener(String(item.id), (state) => {
+        setActionState(state);
+      });
     }
   }, [item?.id]);
 

package/Components/MasterCell/DefaultComponents/BorderContainerView/index.tsx

@@ -117,9 +117,6 @@ export const BorderContainerView = (props: Props) => {
     children,
   } = props;
 
-  const borderStyleForMissingBorder =
-    style?.borderWidth === 0 || !style?.borderColor ? { borderRadius: 0 } : {};
-
   const padding =
     borderPosition === "outside"
       ? {
@@ -131,10 +128,7 @@ export const BorderContainerView = (props: Props) => {
       : {};
 
   return (
-    <View
-      {...props}
-      style={[style, styles.container, borderStyleForMissingBorder]}
-    >
+    <View pointerEvents="box-none" {...props} style={[style, styles.container]}>
       <Border style={style} padding={padding} borderPosition={borderPosition} />
       {children}
     </View>