@applicaster/zapp-react-native-ui-components 13.0.0-alpha.7122212380 → 13.0.0-alpha.7196055925

package/Components/MasterCell/dataAdapter.ts

@@ -35,6 +35,7 @@ function retrieveData(entry, func, args) {
  * @param {?[Object]} element.elements Optional array of nested elements to render within the current node
  * @returns {Object} inflated configuration, ready to be rendered by the master cell's element mapper
  */
+
 export function configInflater(
   entry: any,
   {
@@ -64,7 +65,7 @@ export function configInflater(
 
   if (Array.isArray(elements)) {
     adjustedElements = elements.map((element) =>
-      configInflater(entry, element)
+      configInflater(entry, element as any)
     );
   }
 
@@ -76,14 +77,6 @@ export function configInflater(
   };
 }
 
-/**
- * Memoized version of configInflater to cache results based on entry and masterCellConfig
- */
-const memoizedConfigInflater = R.memoizeWith(
-  (entry, config) => `${entry.id}-${JSON.stringify(config)}`,
-  configInflater
-);
-
 /**
  * Return the proper view tree according to entry's content type and UI state.
  * Falls back to "default" content type or state.
@@ -104,7 +97,7 @@ function resolveElementsNode(entry, state, elements) {
 export function defaultDataAdapter(elements) {
   return function elementsBuilder({ entry, state = "default" }) {
     return resolveElementsNode(entry, state, elements).map((element) =>
-      memoizedConfigInflater(entry, element)
+      configInflater(entry, element)
     );
   };
 }

package/Components/MasterCell/utils/index.ts

@@ -78,17 +78,13 @@ export function resolveColor(entry, style) {
     return style;
   }
 
-  // Iterate through style object keys and resolve any color properties
-  // non-color properties are passed through unchanged
-  const resolvedStyle = Object.keys(style).reduce((acc, key) => {
-    if (key.includes("color") || key.includes("Color")) {
-      return { ...acc, ...resolveColorForProp(entry, acc, key) };
-    }
+  // TODO can be optimized to remove 3 O(n) loops
+  const styleKeys = Object.keys(style);
+  const colorKeys = styleKeys.filter((key) => /color/i.test(key));
 
-    return acc;
+  return colorKeys.reduce((acc, value) => {
+    return { ...style, ...resolveColorForProp(entry, acc, value) };
   }, style);
-
-  return resolvedStyle;
 }
 
 export function isVideoPreviewEnabled({
@@ -343,23 +339,13 @@ export const useCellState = ({
   return getCellState({ focused, selected: _isSelected });
 };
 
-const cache = new Map<string, any>();
-
 export const hasFocusableInsideBuilder = (elementsBuilder) => (item) => {
   const elements = elementsBuilder({ entry: item });
 
-  if (cache.has(item.id)) {
-    return cache.get(item.id);
-  }
-
-  const result = R.anyPass([
+  return R.anyPass([
     hasElementsSpecificViewType("ButtonContainerView"),
     hasElementsSpecificViewType("FocusableView"),
   ])(elements);
-
-  cache.set(item.id, result);
-
-  return result;
 };
 
 export function getEntryState(state, selected) {

package/Components/ModalComponent/Header/index.tsx

@@ -1,5 +1,5 @@
 import React, { useMemo } from "react";
-import { View, StyleSheet, LayoutChangeEvent } from "react-native";
+import { LayoutChangeEvent, StyleSheet, View } from "react-native";
 import { Title, TitleProps } from "./Title";
 import { CloseButton, CloseButtonProps } from "./CloseButton";
 import { getCloseButtonProps, getTitleProps } from "./utils";
@@ -60,8 +60,8 @@ export function ModalHeader(props: Props) {
           width: width - buttonsContainerWidth,
         }}
       >
-        {title && <Title {...titleProps} />}
-        {summary && <Title {...summaryProps} />}
+        {title ? <Title {...titleProps} /> : null}
+        {summary ? <Title {...summaryProps} /> : null}
       </View>
       <View style={{ width: buttonsContainerWidth }}>
         <CloseButton {...closeButtonProps} />

package/Components/River/ComponentsMap/ComponentsMap.tsx

@@ -70,21 +70,6 @@ function ComponentsMapComponent(props: Props) {
 
   const [flatListHeight, setFlatListHeight] = React.useState(null);
 
-  const {
-    isAnyLoading,
-    isAllLoaded,
-    waitForAllComponents,
-    onLoadFinished,
-    onLoadFailed,
-    shouldShowLoadingError,
-    isAnyLoaded,
-    arePreviousComponentsLoaded,
-  } = useLoadingState(feed?.entry?.length || components.length);
-
-  const theme = useTheme();
-
-  const logTimestamp = useProfilerLogging();
-
   const riverComponents = React.useMemo(() => {
     if (feed?.entry?.length < components.length) {
       return R.slice(0, feed?.entry?.length, components);
@@ -93,55 +78,42 @@ function ComponentsMapComponent(props: Props) {
     return components;
   }, [components, feed]);
 
+  const logTimestamp = useProfilerLogging();
+
+  const onLoadDone = React.useCallback(() => {
+    logTimestamp(riverId?.toString());
+  }, [logTimestamp]);
+
+  const { loadingState, onLoadFinished, onLoadFailed, shouldShowLoadingError } =
+    useLoadingState(riverComponents.length, onLoadDone);
+
+  const theme = useTheme();
+
   const renderRiverItem = React.useCallback(
     ({ item, index }) => {
-      const readyToBeDisplayed = arePreviousComponentsLoaded(index);
-
-      const styles = {
-        display: !readyToBeDisplayed ? "none" : ("flex" as "none" | "flex"),
+      const riverItemProps = {
+        riverId,
+        item,
+        index,
+        isScreenWrappedInContainer,
+        feed,
+        groupId,
+        onLoadFailed,
+        onLoadFinished,
+        getStaticComponentFeed,
+        isLast: isLast(index, riverComponents.length),
+        loadingState,
       };
 
       return (
-        <View style={styles}>
-          <ScreenLoadingMeasurementsListItemWrapper index={index}>
-            <RiverItem
-              {...{
-                readyToBeDisplayed,
-                riverId,
-                item,
-                index,
-                isScreenWrappedInContainer,
-                feed,
-                groupId,
-                onLoadFailed,
-                onLoadFinished,
-                getStaticComponentFeed,
-                isLast: isLast(index, riverComponents.length),
-              }}
-            />
-          </ScreenLoadingMeasurementsListItemWrapper>
-        </View>
+        <ScreenLoadingMeasurementsListItemWrapper index={index}>
+          <RiverItem {...riverItemProps} />
+        </ScreenLoadingMeasurementsListItemWrapper>
       );
     },
-    [
-      feed,
-      getStaticComponentFeed,
-      arePreviousComponentsLoaded,
-      onLoadFailed,
-      onLoadFinished,
-    ]
+    [feed, getStaticComponentFeed, onLoadFailed, onLoadFinished]
   );
 
-  const renderFooter = React.useCallback(() => {
-    return (
-      <RiverFooter
-        visible={isAnyLoading}
-        flatListHeight={flatListHeight}
-        isAnyLoaded={isAnyLoaded || waitForAllComponents}
-      />
-    );
-  }, [flatListHeight, isAnyLoading, isAnyLoaded]);
-
   const screenStyle = React.useMemo(
     () => ({
       paddingTop: ifEmptyUseFallback(
@@ -179,12 +151,6 @@ function ComponentsMapComponent(props: Props) {
 
   usePipesCacheReset(riverId, riverComponents);
 
-  React.useEffect(() => {
-    if (isAllLoaded) {
-      logTimestamp(riverId?.toString());
-    }
-  }, [isAllLoaded]);
-
   const refreshControl = React.useMemo(
     () =>
       pullToRefreshEnabled ? (
@@ -280,6 +246,11 @@ function ComponentsMapComponent(props: Props) {
     }
   }, []);
 
+  const contentContainerStyle = React.useMemo(
+    () => (isScreenWrappedInContainer ? {} : screenStyle),
+    [isScreenWrappedInContainer, screenStyle]
+  );
+
   if (shouldShowLoadingError) {
     return <RiverError />;
   }
@@ -291,7 +262,7 @@ function ComponentsMapComponent(props: Props) {
     <View style={styles.container}>
       <ScreenLoadingMeasurements
         riverId={riverId}
-        numberOfComponents={feed?.entry?.length || components.length}
+        numberOfComponents={riverComponents.length}
       >
         <ViewportTracker>
           <FlatList
@@ -312,10 +283,13 @@ function ComponentsMapComponent(props: Props) {
             keyExtractor={keyExtractor}
             renderItem={renderRiverItem}
             data={riverComponents}
-            contentContainerStyle={
-              isScreenWrappedInContainer ? {} : screenStyle
+            contentContainerStyle={contentContainerStyle}
+            ListFooterComponent={
+              <RiverFooter
+                flatListHeight={flatListHeight}
+                loadingState={loadingState}
+              />
             }
-            ListFooterComponent={renderFooter}
             refreshControl={refreshControl}
             onScrollBeginDrag={onScrollBeginDrag}
             onScroll={onScroll}

package/Components/River/ComponentsMap/hooks/useLoadingState.ts

@@ -1,50 +1,86 @@
 import * as React from "react";
-import * as R from "ramda";
-
-const allTrue = R.all(R.equals(true));
-const anyFalse = R.any(R.equals(false));
-const anyTrue = R.any(R.equals(true));
+import { isNil, set, lensIndex, T, slice } from "ramda";
+import { BehaviorSubject } from "rxjs";
+import { useRefWithInitialValue } from "@applicaster/zapp-react-native-utils/reactHooks/state/useRefWithInitialValue";
 
 const reducer = (state, { payload }) => {
-  if (!R.isNil(payload) && !state[payload]) {
-    return R.set(R.lensIndex(payload), true)(state);
+  if (!isNil(payload) && !state[payload]) {
+    return set(lensIndex(payload), true)(state);
   }
 
   return state;
 };
 
-type Return = {
-  isAnyLoading: boolean;
-  isAllLoaded: boolean;
+type LoadingState = {
+  index: number;
+  done: boolean;
   waitForAllComponents: boolean;
+};
+
+type Return = {
+  loadingState: BehaviorSubject<LoadingState>;
   onLoadFinished: (index: number) => void;
   onLoadFailed: ({ error, index }: { error: Error; index: number }) => void;
   shouldShowLoadingError: boolean;
-  isAnyLoaded: boolean;
   arePreviousComponentsLoaded: (index: number) => boolean;
 };
 
-type Action = { payload: { index: number } };
-
-type Loaded = true;
-type Loading = false;
-
-type LoadingState = Array<Loaded | Loading>;
-
 // TODO: Take this value from Zapp configuration, when feature is added to GeneralScreen
 const SHOULD_FAIL_ON_COMPONENT_LOADING = false;
 
-export const useLoadingState = (count: number): Return => {
+const createLoadingStateObservable = () =>
+  new BehaviorSubject<LoadingState>({
+    index: -1,
+    done: false,
+    waitForAllComponents: SHOULD_FAIL_ON_COMPONENT_LOADING,
+  });
+
+export const useLoadingState = (
+  count: number,
+  onLoadDone: () => void
+): Return => {
+  const componentStateRef = React.useRef(new Array(count).fill(false));
   const [loadingError, setLoadingError] = React.useState(null);
 
-  const [componentsState, dispatch] = React.useReducer<
-    React.Reducer<LoadingState, Action>
-  >(reducer, new Array(count).fill(false));
+  const loadingState = useRefWithInitialValue<BehaviorSubject<LoadingState>>(
+    createLoadingStateObservable
+  );
+
+  const arePreviousComponentsLoaded = React.useCallback((index) => {
+    if (index === 0) {
+      return true;
+    }
 
-  const handleComponentLoaded = React.useCallback((index) => {
-    dispatch({ payload: index });
+    const componentsBefore = slice(0, index, componentStateRef.current);
+
+    return componentsBefore.every(T);
   }, []);
 
+  const dispatch = React.useCallback(({ payload }) => {
+    const newState = reducer(componentStateRef.current, { payload });
+    componentStateRef.current = newState;
+    const isDone = arePreviousComponentsLoaded(count - 1);
+
+    const state = loadingState.current.getValue();
+
+    const newLoadingState = {
+      ...state,
+      index: state.index < payload ? payload : state.index,
+      done: isDone,
+    };
+
+    loadingState.current.next(newLoadingState);
+
+    if (isDone) {
+      onLoadDone();
+    }
+  }, []);
+
+  const handleComponentLoaded = React.useCallback(
+    (index) => dispatch({ payload: index }),
+    []
+  );
+
   const handleComponentLoadErrorWhenNeedToFail = React.useCallback(
     ({ error }) => {
       if (error !== loadingError) {
@@ -55,35 +91,26 @@ export const useLoadingState = (count: number): Return => {
   );
 
   const handleComponentLoadErrorWhenNoNeedToFail = React.useCallback(
-    ({ index }) => {
-      handleComponentLoaded(index);
-    },
+    ({ index }) => handleComponentLoaded(index),
     []
   );
 
-  const arePreviousComponentsLoaded = React.useCallback(
-    (index) => {
-      if (index === 0) {
-        return true;
-      }
-
-      const componentsBefore = R.slice(0, index, componentsState);
-
-      return allTrue(componentsBefore);
-    },
-    [componentsState]
+  return React.useMemo(
+    () => ({
+      loadingState: loadingState.current,
+      onLoadFinished: handleComponentLoaded,
+      onLoadFailed: SHOULD_FAIL_ON_COMPONENT_LOADING
+        ? handleComponentLoadErrorWhenNeedToFail
+        : handleComponentLoadErrorWhenNoNeedToFail,
+      shouldShowLoadingError: SHOULD_FAIL_ON_COMPONENT_LOADING && loadingError,
+      arePreviousComponentsLoaded,
+    }),
+    [
+      loadingError,
+      handleComponentLoaded,
+      handleComponentLoadErrorWhenNeedToFail,
+      handleComponentLoadErrorWhenNoNeedToFail,
+      arePreviousComponentsLoaded,
+    ]
   );
-
-  return {
-    isAnyLoading: anyFalse(componentsState),
-    isAllLoaded: allTrue(componentsState),
-    onLoadFinished: handleComponentLoaded,
-    onLoadFailed: SHOULD_FAIL_ON_COMPONENT_LOADING
-      ? handleComponentLoadErrorWhenNeedToFail
-      : handleComponentLoadErrorWhenNoNeedToFail,
-    shouldShowLoadingError: SHOULD_FAIL_ON_COMPONENT_LOADING && loadingError,
-    isAnyLoaded: anyTrue(componentsState),
-    waitForAllComponents: SHOULD_FAIL_ON_COMPONENT_LOADING,
-    arePreviousComponentsLoaded,
-  };
 };

package/Components/River/RiverFooter.tsx

@@ -1,11 +1,23 @@
-import React from "react";
+import React, { useCallback } from "react";
 import { StyleSheet, View } from "react-native";
 import { Spinner } from "@applicaster/zapp-react-native-ui-components/Components/Spinner";
+import type { Subject } from "rxjs";
+import { useStateFromSubscribe } from "@applicaster/zapp-react-native-utils/reactHooks/state/useStateFromSubscribe";
+
+type LoadingState = {
+  waitForAllComponents: boolean;
+  index: number;
+  done: boolean;
+};
+
+type State = {
+  visible: boolean;
+  isAnyLoaded: boolean;
+};
 
 type Props = {
-  visible?: boolean;
   flatListHeight?: number;
-  isAnyLoaded: boolean;
+  loadingState: Subject<LoadingState>;
 };
 
 const FOOTER_COMPONENT_HEIGHT = 200;
@@ -19,17 +31,35 @@ const footerStyles = StyleSheet.create({
 });
 
 function RiverFooterComponent(props: Props) {
-  const { visible = true, flatListHeight, isAnyLoaded } = props;
+  const { flatListHeight, loadingState } = props;
+
+  const { visible, isAnyLoaded } = useStateFromSubscribe<LoadingState, State>(
+    loadingState,
+    useCallback(
+      ({ index, done, waitForAllComponents }, setState) =>
+        setState(() => ({
+          visible: !done,
+          isAnyLoaded: index >= 0 || waitForAllComponents,
+        })),
+      []
+    ),
+    {
+      visible: true,
+      isAnyLoaded: false,
+    }
+  );
 
   if (!visible) return null;
 
   return (
     <View
-      renderToHardwareTextureAndroid={true}
-      style={{
-        ...footerStyles.container,
-        height: isAnyLoaded ? FOOTER_COMPONENT_HEIGHT : flatListHeight,
-      }}
+      renderToHardwareTextureAndroid
+      style={[
+        footerStyles.container,
+        {
+          height: isAnyLoaded ? FOOTER_COMPONENT_HEIGHT : flatListHeight,
+        },
+      ]}
     >
       <Spinner size={isAnyLoaded ? "small" : "large"} />
     </View>

package/Components/River/RiverItem.tsx

@@ -1,4 +1,4 @@
-import React from "react";
+import React, { useEffect } from "react";
 import * as R from "ramda";
 
 import { applyDecorators } from "../../Decorators";
@@ -11,6 +11,7 @@ import {
 import { riverLogger } from "./logger";
 import { tvPluginsWithCellRenderer } from "../../const";
 import { isTV } from "@applicaster/zapp-react-native-utils/reactUtils";
+import type { BehaviorSubject } from "rxjs";
 
 export type RiverItemType = {
   item: ZappUIComponent;
@@ -24,6 +25,7 @@ export type RiverItemType = {
   getStaticComponentFeed: GeneralContentScreenProps["getStaticComponentFeed"];
   readyToBeDisplayed?: boolean;
   isLast: boolean;
+  loadingState: BehaviorSubject<{ index: number }>;
 };
 
 function getFeedUrl(feed: ZappFeed, index: number) {
@@ -36,6 +38,33 @@ function getFeedUrl(feed: ZappFeed, index: number) {
   }
 }
 
+/**
+ * useLoadingState for RiverItemComponent
+ * takes currentIndex and loadingState as arguments
+ **/
+const useLoadingState = (
+  currentIndex: number,
+  loadingState: RiverItemType["loadingState"]
+) => {
+  const [readyToBeDisplayed, setReadyToBeDisplayed] = React.useState(
+    loadingState.getValue().index + 1 === currentIndex
+  );
+
+  useEffect(() => {
+    const subscription = loadingState.subscribe(({ index }) => {
+      if (index + 1 === currentIndex) {
+        setReadyToBeDisplayed(true);
+      }
+    });
+
+    return () => {
+      subscription.unsubscribe();
+    };
+  }, [loadingState, currentIndex]);
+
+  return readyToBeDisplayed;
+};
+
 function RiverItemComponent(props: RiverItemType) {
   const {
     item,
@@ -47,10 +76,12 @@ function RiverItemComponent(props: RiverItemType) {
     onLoadFinished,
     onLoadFailed,
     getStaticComponentFeed,
-    readyToBeDisplayed,
     isLast,
+    loadingState,
   } = props;
 
+  const readyToBeDisplayed = useLoadingState(index, loadingState);
+
   const feedUrl = getFeedUrl(feed, index);
 
   const Component = useComponentResolver(
@@ -90,6 +121,10 @@ function RiverItemComponent(props: RiverItemType) {
     }
   }, []);
 
+  if (!readyToBeDisplayed) {
+    return null;
+  }
+
   if (Component === null || typeof Component === "undefined") {
     riverLogger.warning({
       message: `Component ${item.component_type} is null - skipping rendering`,