@applicaster/zapp-react-native-ui-components 13.0.0-alpha.8865612391 → 13.0.0-alpha.8865907528

package/Components/AnimatedInOut/index.tsx

@@ -4,9 +4,11 @@ import { usePrevious } from "@applicaster/zapp-react-native-utils/reactHooks/uti
 import { toBooleanWithDefaultFalse } from "@applicaster/zapp-react-native-utils/booleanUtils";
 import { noop } from "@applicaster/zapp-react-native-utils/functionUtils";
 
-type AnimatedInterpolatedStyle =
-  | Animated.AnimatedInterpolation
-  | [{ [Key: string]: Animated.AnimatedInterpolation }];
+type AnimatedInterpolatedStyle = any;
+
+// type AnimatedInterpolatedStyle =
+//   | Animated.AnimatedInterpolation
+//   | [{ [Key: string]: Animated.AnimatedInterpolation }];
 
 type AnimationConfig = {
   duration: number;

package/Components/FocusableGroup/FocusableTvOS.tsx

@@ -1,17 +1,31 @@
 import * as React from "react";
 import { FocusableGroupNative } from "@applicaster/zapp-react-native-ui-components/Components/NativeFocusables";
 import { BaseFocusable } from "@applicaster/zapp-react-native-ui-components/Components/BaseFocusable";
-
-function noop() {}
+import { createLogger } from "@applicaster/zapp-react-native-utils/logger";
+
+const { log_verbose } = createLogger({
+  subsystem: "General",
+  category: "FocusableGroup",
+});
+
+type FocusableGroupNativeEvent = {
+  nativeEvent: {
+    focusHeading: FocusManager.Direction;
+    groupId: string;
+    isActive: boolean;
+    isFocusDisabled: boolean;
+    isFocusingByUser: boolean;
+    itemId: string;
+    target: number;
+  };
+};
 
 type Props = {
   id: string;
   children: (arg1: boolean) => React.ComponentType<any>;
-  onWillUpdateFocus: (nativeEvent: any) => void;
-  onDidUpdateFocus: (nativeEvent: any) => void;
   isFocusDisabled: boolean;
   initialItemId: string;
-  resetFocusToInitialValue: boolean;
+  isPreferredFocusDisabled: boolean;
   focusGroupRef: React.Component;
   shouldUsePreferredFocus: boolean;
   groupId: string;
@@ -21,86 +35,27 @@ type Props = {
 };
 
 export class FocusableGroup extends BaseFocusable<Props> {
-  focusableGroupNativeRef: React.Component | null;
-  constructor(props) {
-    super(props);
-    this.focusableGroupNativeRef = null;
-
-    this.state = {
-      isActive: false,
-    };
-
-    this.onWillUpdateFocus = this.onWillUpdateFocus.bind(this);
-    this.onDidUpdateFocus = this.onDidUpdateFocus.bind(this);
-    this.isGroup = true;
-
-    this.shouldUsePreferredFocus = this.shouldUsePreferredFocus.bind(this);
-    this.measureView = this.measureView.bind(this);
-  }
-
-  connectedScreenId() {
-    const {
-      screenData: { screenId, parentScreenId },
-    } = this.props;
-
-    if (screenId) {
-      return null;
-    }
-
-    return parentScreenId ? `${parentScreenId}-${screenId}` : screenId;
-  }
-
-  /**
-   * tells whether the group should give focus to a preferred item when it gains focus from another
-   * group
-   * @returns {boolean}
-   */
-  shouldUsePreferredFocus() {
-    return this.props.shouldUsePreferredFocus || false;
-  }
-
-  /**
-   * indicates whether the underlying component should claim preferred focus
-   * when navigating into the group of this item
-   * @returns {boolean}
-   */
-  isPreferredFocus() {
-    return this.props.preferredFocus || false;
-  }
-
-  onWillUpdateFocus({ nativeEvent }) {
-    const { isActive } = nativeEvent;
-    this.setState({ isActive });
-    const { onWillUpdateFocus = noop } = this.props;
-    onWillUpdateFocus(nativeEvent);
-  }
-
-  onDidUpdateFocus({ nativeEvent }) {
-    const { onDidUpdateFocus = noop } = this.props;
-    onDidUpdateFocus(nativeEvent);
-  }
-
-  setFocusDisabled(isFocusDisabled) {
-    if (this.ref) {
-      this.ref.current.setNativeProps({
-        isFocusDisabled,
-      });
-    }
-  }
-
   render() {
     const {
       children,
       id,
       isFocusDisabled,
       initialItemId,
-      resetFocusToInitialValue,
-      style,
+      isPreferredFocusDisabled,
+      style = {},
       groupId,
       ...otherProps
     } = this.props;
 
-    const focusableStyles = style || {};
+    const onGroupFocus = ({ nativeEvent }: FocusableGroupNativeEvent) => {
+      log_verbose("FOCUSABLE_GROUP: onGroupFocus", { nativeEvent });
+      this.onFocus(this.ref, nativeEvent.focusHeading);
+    };
+
+    const onGroupBlur = ({ nativeEvent }: FocusableGroupNativeEvent) => {
+      log_verbose("FOCUSABLE_GROUP: onGroupBlur", { nativeEvent });
+      this.onBlur(this.ref, nativeEvent.focusHeading);
+    };
 
     return (
       <FocusableGroupNative
@@ -109,15 +64,11 @@ export class FocusableGroup extends BaseFocusable<Props> {
         ref={this.ref}
         isFocusDisabled={isFocusDisabled}
         initialItemId={initialItemId}
-        resetFocusToInitialValue={resetFocusToInitialValue}
-        onLayout={this.measureView}
-        onViewFocus={this.onFocus}
-        onViewPress={this.onPress}
-        onViewBlur={this.onBlur}
-        style={focusableStyles}
+        isPreferredFocusDisabled={isPreferredFocusDisabled}
+        onGroupFocus={onGroupFocus}
+        onGroupBlur={onGroupBlur}
+        style={style}
         {...otherProps}
-        onWillUpdateFocus={this.onWillUpdateFocus}
-        onDidUpdateFocus={this.onDidUpdateFocus}
       >
         {children}
       </FocusableGroupNative>

package/Components/FocusableGroup/index.tsx

@@ -16,12 +16,10 @@ type Props = {
   prioritiseFocusOn?: number;
   groupId?: string;
   hasTVPreferredFocus?: boolean;
-  resetFocusToInitialValue?: boolean;
+  isPreferredFocusDisabled?: boolean;
   onFocus?: () => void;
   onBlur?: () => void;
-  onWillUpdateFocus?: (event?: any) => void;
   willReceiveFocus?: (event?: any) => void;
-  onDidUpdateFocus?: (event?: any) => void;
   hasLostFocus?: any;
   nextFocusUp?: any;
   nextFocusDown?: any;

package/Components/Layout/TV/ScreenContainer.tsx

@@ -55,8 +55,11 @@ export const ScreenContainer = React.memo(function ScreenContainer({
   ComponentsExtraProps,
   NavBar,
 }: Props) {
-  const { screenMarginBottom } = React.useContext(ScreenLayoutContext);
+  const { screenMarginBottom, resetScreenLayout } =
+    React.useContext(ScreenLayoutContext);
+
   const { currentRoute, screenData } = useNavigation();
+
   const screen = useCurrentScreenData();
 
   const { marginBottom, backgroundColor, paddingTop, paddingBottom } =
@@ -65,6 +68,10 @@ export const ScreenContainer = React.memo(function ScreenContainer({
   const theme = useTheme();
   const getThemeValue = React.useCallback(R.propOr(0, R.__, theme), [theme]);
 
+  React.useEffect(() => {
+    resetScreenLayout();
+  }, [currentRoute]);
+
   const fullscreen = React.useCallback(
     displayFullScreen({ currentRoute, screenData }),
     [currentRoute, screenData]

package/Components/Layout/TV/ScreenLayoutContextProvider.tsx

@@ -60,10 +60,15 @@ export function ScreenLayoutContextProvider(props: {
     initialState
   );
 
+  const resetScreenLayout = React.useCallback(() => {
+    setScreenLayout(initialState);
+  }, [initialState]);
+
   const screenLayoutValue = React.useMemo(
     () => ({
       ...screenLayout,
       setScreenLayout,
+      resetScreenLayout,
     }),
     [screenLayout]
   );

package/Components/Layout/TV/__tests__/ScreenContainer.test.tsx

@@ -56,11 +56,12 @@ describe("ScreenContainer", () => {
   };
 
   const setScreenLayout = () => {};
+  const resetScreenLayout = () => {};
 
   const wrapper = ({ children }) => (
     <WrappedWithProviders>
       <ScreenLayoutContext.Provider
-        value={{ ...screenLayout, setScreenLayout }}
+        value={{ ...screenLayout, setScreenLayout, resetScreenLayout }}
       >
         <ScreenContainer NavBar={View}>{children}</ScreenContainer>
       </ScreenLayoutContext.Provider>

package/Components/MasterCell/elementMapper.tsx

@@ -73,7 +73,6 @@ export function elementMapper(
       : {};
 
     const componentProps = {
-      key,
       style,
       skipButtons: otherProps?.skipButtons,
       emitAsyncElementRegistrate: otherProps?.emitAsyncElementRegistrate,
@@ -91,7 +90,7 @@ export function elementMapper(
     const fn = mapElementWithKey(elementMapper(components, otherProps));
 
     return (
-      <Component {...componentProps}>
+      <Component key={key} {...componentProps}>
         {focusableTypes.has(type) && elements.length > 0
           ? elements.map(fn)
           : null}

package/Components/MasterCell/utils/behaviorProvider.ts

@@ -0,0 +1,133 @@
+import { playerManager } from "@applicaster/zapp-react-native-utils/appUtils";
+import { StorageSingleValueProvider } from "@applicaster/zapp-react-native-bridge/ZappStorage/StorageSingleSelectProvider";
+import { PushTopicManager } from "@applicaster/zapp-react-native-bridge/PushNotifications/PushTopicManager";
+import { StorageMultiSelectProvider } from "@applicaster/zapp-react-native-bridge/ZappStorage/StorageMultiSelectProvider";
+import React, { useEffect } from "react";
+import { usePlayer } from "@applicaster/zapp-react-native-utils/appUtils/playerManager/usePlayer";
+import { BehaviorSubject } from "rxjs";
+import { masterCellLogger } from "../logger";
+
+const parseContextKey = (key: string): string | null => {
+  if (!key?.startsWith("@{ctx/")) return null;
+
+  return key.substring("@{ctx/".length, key.length - 1);
+};
+
+const getDataSourceProvider = (
+  behavior: Behavior
+): BehaviorSubject<string[] | string> | null => {
+  if (!behavior) return null;
+
+  const selection = String(behavior.current_selection);
+  const contextKey = parseContextKey(selection);
+
+  if (contextKey) {
+    if (behavior.select_mode === "multi") {
+      return StorageMultiSelectProvider.getProvider(contextKey).getObservable();
+    }
+
+    if (behavior.select_mode === "single") {
+      return StorageSingleValueProvider.getProvider(contextKey).getObservable();
+    }
+  }
+
+  if (behavior.selection_source === "@{push/topics}") {
+    return PushTopicManager.getInstance().getEntryObservable();
+  }
+
+  return null;
+};
+
+export const useBehaviorUpdate = (behavior: Behavior) => {
+  const [lastUpdate, setLastUpdate] = React.useState<number | null>(null);
+  const player = usePlayer();
+
+  const triggerUpdate = () => setLastUpdate(Date.now());
+
+  useEffect(() => {
+    if (!behavior) return;
+
+    const dataSource = getDataSourceProvider(behavior);
+
+    if (dataSource) {
+      const subscription = dataSource.subscribe(triggerUpdate);
+
+      return () => subscription.unsubscribe();
+    }
+  }, [behavior]);
+
+  useEffect(() => {
+    if (!behavior || !player || behavior.selection_source !== "now_playing") {
+      return;
+    }
+
+    const subscription = player.getEntryObservable().subscribe(triggerUpdate);
+
+    return () => subscription.unsubscribe();
+  }, [behavior, player]);
+
+  return lastUpdate;
+};
+
+// We cant use async in this function (its inside render),
+// so we rely on useBehaviorUpdate to update current value and trigger re-render
+export const isCellSelected = (
+  id: string | number,
+  behavior?: Behavior
+): boolean => {
+  if (!behavior) return false;
+
+  if (behavior.selection_source === "now_playing") {
+    const player = playerManager.getActivePlayer();
+
+    return player?.entry?.id === id;
+  }
+
+  if (behavior.selection_source === "@{push/topics}") {
+    if (behavior.select_mode === "single") {
+      masterCellLogger.warning(
+        "Unexpected single selection mode for push topics"
+      );
+    }
+
+    const tags = PushTopicManager.getInstance().getRegisteredTags();
+
+    return tags.includes(String(id));
+  }
+
+  const selection = String(behavior.current_selection);
+  const contextKey = parseContextKey(selection);
+
+  if (contextKey) {
+    if (behavior.select_mode === "single") {
+      const selectedItem =
+        StorageSingleValueProvider.getProvider(contextKey)?.getValue();
+
+      return selectedItem === String(id);
+    }
+
+    if (behavior.select_mode === "multi") {
+      const selectedItems =
+        StorageMultiSelectProvider.getProvider(contextKey)?.getSelectedItems();
+
+      return selectedItems?.includes(String(id));
+    }
+  }
+
+  if (behavior.select_mode === "single") {
+    return behavior.current_selection === id;
+  }
+
+  if (
+    behavior.select_mode === "multi" &&
+    Array.isArray(behavior.current_selection)
+  ) {
+    const currentSelection: string[] = behavior.current_selection.map(
+      (item): string => String(item)
+    );
+
+    return currentSelection.includes(String(id));
+  }
+
+  return false;
+};

package/Components/MasterCell/utils/index.ts

@@ -1,16 +1,13 @@
-import React, { useEffect, useMemo } from "react";
+import React, { useMemo } from "react";
 import * as R from "ramda";
 import validateColor from "validate-color";
 import { platformSelect } from "@applicaster/zapp-react-native-utils/reactUtils";
 import { useActions } from "@applicaster/zapp-react-native-utils/reactHooks/actions";
 
 import { masterCellLogger } from "../logger";
-import { playerManager } from "@applicaster/zapp-react-native-utils/appUtils";
-import { usePlayer } from "@applicaster/zapp-react-native-utils/appUtils/playerManager/usePlayer";
-import { PushTopicManager } from "@applicaster/zapp-react-native-bridge/PushNotifications/PushTopicManager";
-import { StorageMultiSelectProvider } from "@applicaster/zapp-react-native-bridge/ZappStorage/StorageMultiSelectProvider";
 import { getCellState } from "../../Cell/utils";
 import { getColorFromData } from "@applicaster/zapp-react-native-utils/cellUtils";
+import { isCellSelected, useBehaviorUpdate } from "./behaviorProvider";
 
 const hasElementSpecificViewType = (viewType) => (element) => {
   if (R.isNil(element)) {
@@ -194,130 +191,7 @@ export const getFocusedButtonId = (focusable) => {
 };
 
 export const isSelected = (id: string | number, behavior?: Behavior) => {
-  if (!behavior) {
-    return false;
-  }
-
-  if (behavior?.selection_source === "now_playing") {
-    const player = playerManager.getActivePlayer();
-
-    if (player?.entry?.id === id) {
-      return true;
-    }
-  }
-
-  if (behavior?.select_mode === "single") {
-    return behavior.current_selection === id;
-  }
-
-  if (behavior?.select_mode === "multi") {
-    // TODO: Use generic resolver source
-
-    if (behavior.selection_source === "@{push/topics}") {
-      const tags = PushTopicManager.getInstance().getRegisteredTags();
-
-      return tags.includes(String(id));
-    }
-
-    if (Array.isArray(behavior.current_selection)) {
-      return behavior.current_selection.includes(id);
-    }
-
-    const currentSelection = String(behavior.current_selection);
-
-    if (currentSelection?.startsWith("@{ctx/")) {
-      const keyWithoutCtx = currentSelection.substring(
-        "@{ctx/".length,
-        currentSelection.length - 1
-      );
-
-      const selectedItems =
-        StorageMultiSelectProvider.getProvider(
-          keyWithoutCtx
-        )?.getSelectedItems();
-
-      return selectedItems?.includes(String(id));
-    }
-  }
-
-  return false;
-};
-
-export const useBehaviorUpdate = (behavior: Behavior) => {
-  const [lastUpdate, setLastUpdate] = React.useState(null);
-
-  const player = usePlayer();
-
-  const triggerUpdate = () => {
-    setLastUpdate(Date.now());
-  };
-
-  // TODO: Create generic RX to state update
-  useEffect(() => {
-    // TODO: Use generic resolver source
-    if (!behavior) {
-      return;
-    }
-
-    const currentSelection = String(behavior.current_selection);
-
-    if (currentSelection?.startsWith("@{ctx/")) {
-      const keyWithoutCtx = currentSelection.substring(
-        "@{ctx/".length,
-        currentSelection.length - 1
-      );
-
-      if (keyWithoutCtx) {
-        const subscription = StorageMultiSelectProvider.getProvider(
-          keyWithoutCtx
-        )
-          .getObservable()
-          .subscribe(() => {
-            triggerUpdate();
-          });
-
-        return () => {
-          subscription.unsubscribe();
-        };
-      }
-    }
-  }, [behavior]);
-
-  useEffect(() => {
-    if (!behavior) {
-      return;
-    }
-
-    if (behavior?.selection_source === "@{push/topics}") {
-      const subscription = PushTopicManager.getInstance()
-        .getEntryObservable()
-        .subscribe(() => {
-          triggerUpdate();
-        });
-
-      return () => {
-        subscription.unsubscribe();
-      };
-    }
-  }, [behavior]);
-
-  useEffect(() => {
-    if (!behavior) {
-      return;
-    }
-
-    if (behavior?.selection_source === "now_playing" && player) {
-      const subscription = player.getEntryObservable().subscribe(() => {
-        triggerUpdate();
-      });
-
-      return () => {
-        subscription.unsubscribe();
-      };
-    }
-  }, [behavior, player]);
-
-  return lastUpdate;
+  return isCellSelected(id, behavior);
 };
 
 export const useCellState = ({

package/Components/River/ComponentsMap/ComponentsMap.tsx

@@ -279,7 +279,6 @@ function ComponentsMapComponent(props: Props) {
             initialNumToRender={3}
             maxToRenderPerBatch={10}
             windowSize={12}
-            listKey={riverId}
             keyExtractor={keyExtractor}
             renderItem={renderRiverItem}
             data={riverComponents}

package/Components/TrackedView/index.tsx

@@ -12,6 +12,7 @@ type TrackedViewProps = {
   onPositionUpdated: (props: { rect?: Record<string, number> }) => void;
   testId?: string | undefined;
   groupId?: string;
+  clipThreshold?: number;
 };
 
 export const TrackedView = memo(function TrackedView(props: TrackedViewProps) {

package/Components/Transitioner/AnimationManager.js

@@ -2,21 +2,21 @@ import { Animated } from "react-native";
 
 import { NAV_ACTION_PUSH, NAV_ACTION_BACK } from "./Transitioner";
 
-type TransitionConfig = {
-  duration: number;
-  easing: any;
-  from: {
-    style: any;
-  };
-  to: {
-    style: any;
-  };
-};
+// type TransitionConfig = {
+//   duration: number;
+//   easing: any;
+//   from: {
+//     style: any;
+//   };
+//   to: {
+//     style: any;
+//   };
+// };
 
-type Props = {
-  transitionConfig: TransitionConfig;
-  contentStyle: { [string]: any };
-};
+// type Props = {
+//   transitionConfig: TransitionConfig;
+//   contentStyle: { [string]: any };
+// };
 
 /**
  * Manages animation for the Transitioner,
@@ -25,7 +25,7 @@ type Props = {
  * which must have a proper structure, see types above ^.
  */
 export class AnimationManager {
-  constructor(props: Props) {
+  constructor(props) {
     this.animatedValue = new Animated.Value(0.0);
 
     this.config = props.transitionConfig(

package/Components/VideoLive/PlayerLiveImageComponent.tsx

@@ -32,6 +32,9 @@ const { log_error, log_debug } = loggerLiveImageComponent;
 const isMeasurement = (item: ZappEntry) =>
   isString(item.id) && item.id.startsWith("pre-measurement-");
 
+// Pixels by which the view can slightly extend outside the viewport and still be considered fully visible.
+const CLIP_THRESHOLD = 10;
+
 type Props = {
   item: ZappEntry;
   style: Record<string, any>;
@@ -328,6 +331,7 @@ const PlayerLiveImageComponent = (props: Props) => {
     <TrackedView
       testId={`tracked-view-${playerId}-${item.title}`}
       onPositionUpdated={onPositionUpdated}
+      clipThreshold={CLIP_THRESHOLD}
     >
       <View ref={trackViewRef}>
         {isVideoMode ? (

package/Components/VideoLive/__tests__/__snapshots__/PlayerLiveImageComponent.test.tsx.snap

@@ -2,6 +2,7 @@
 
 exports[`PlayerLiveImageComponent should render correctly with default props 1`] = `
 <TrackedView
+  clipThreshold={10}
   onPositionUpdated={[Function]}
   testId="tracked-view-player1-Test"
 >

package/Components/VideoLive/animationUtils.ts

@@ -1,8 +1,8 @@
 import { Animated, Easing, EasingFunction, StyleProp } from "react-native";
 
 type AnimatedInterpolatedStyle =
-  | Animated.AnimatedInterpolation
-  | [{ [Key: string]: Animated.AnimatedInterpolation }];
+  | Animated.AnimatedInterpolation<number>
+  | [{ [Key: string]: Animated.AnimatedInterpolation<number> }];
 
 type AnimationConfig = {
   duration: number;
@@ -31,7 +31,7 @@ const interpolate = (
   animatedValue: Animated.Value,
   from: number = 0,
   to: number = 1
-): Animated.AnimatedInterpolation =>
+): Animated.AnimatedInterpolation<number> =>
   animatedValue.interpolate({
     inputRange: [0, 1],
     outputRange: [from, to],

package/Contexts/FocusableGroupContext/withFocusableContext.tsx

@@ -7,17 +7,11 @@ export const withFocusableContext = (Component) => {
     { groupId, ...props }: Record<string, any>,
     ref
   ) => {
-    return (
-      <FocusableGroupContext.Consumer>
-        {(groupIdContext: string) => {
-          // eslint-disable-next-line react/display-name
-          const propsGroupId = groupId || null;
-          const providedGroupId = propsGroupId || groupIdContext;
+    const groupIdContext = React.useContext(FocusableGroupContext);
+    const propsGroupId = groupId || null;
+    const providedGroupId = propsGroupId || groupIdContext;
 
-          return <Component {...props} groupId={providedGroupId} ref={ref} />;
-        }}
-      </FocusableGroupContext.Consumer>
-    );
+    return <Component {...props} groupId={providedGroupId} ref={ref} />;
   };
 
   return React.forwardRef(WithFocusableContext);

package/Contexts/HeaderOffsetContext/index.tsx

@@ -13,7 +13,7 @@ type ProviderProps = {
   };
 };
 
-const initialHeaderOffsetContext = () => ({
+const initialHeaderOffsetContext: HeaderOffsetContextType = () => ({
   headerOffset: 0,
   headersAbove: null,
 });
@@ -24,11 +24,9 @@ export const HeaderOffsetContext = React.createContext<HeaderOffsetContextType>(
 
 export function withConsumer(Component) {
   return function WithConsumer(props) {
-    return (
-      <HeaderOffsetContext.Consumer>
-        {(context) => <Component getHeaderOffset={context} {...props} />}
-      </HeaderOffsetContext.Consumer>
-    );
+    const getHeaderOffset = React.useContext(HeaderOffsetContext);
+
+    return <Component getHeaderOffset={getHeaderOffset} {...props} />;
   };
 }
 

package/Contexts/ScreenContext/index.tsx

@@ -176,15 +176,8 @@ export function ScreenContextProvider({
 
 export function withScreenContext(Component: React.ComponentType<any>) {
   return function WithScreenContextWrapper(props) {
-    return (
-      <ScreenContext.Consumer>
-        {useCallback(
-          (value) => (
-            <Component {...props} screenContext={value} />
-          ),
-          [Component, props]
-        )}
-      </ScreenContext.Consumer>
-    );
+    const screenContext = React.useContext(ScreenContext);
+
+    return <Component {...props} screenContext={screenContext} />;
   };
 }

package/Contexts/ScreenLayoutContext/index.tsx

@@ -8,10 +8,11 @@ type LayoutContext = {
   componentAnchorPointY: number | null;
   componentAvailableWidth: number | null;
   setScreenLayout?: (properties: {}) => void;
+  resetScreenLayout?: () => void;
   extraAnchorPointYOffset: number;
 };
 
-const screenLayoutContext: LayoutContext = {
+const initialScreenLayoutContext: LayoutContext = {
   screenMarginTop: null,
   screenMarginBottom: null,
   screenHeight: null,
@@ -21,8 +22,9 @@ const screenLayoutContext: LayoutContext = {
   extraAnchorPointYOffset: 0,
 };
 
-export const ScreenLayoutContext =
-  React.createContext<LayoutContext>(screenLayoutContext);
+export const ScreenLayoutContext = React.createContext<LayoutContext>(
+  initialScreenLayoutContext
+);
 
 export function ScreenLayoutContextConsumer(Component) {
   return function WithConsumer(props) {

package/Decorators/ConfigurationWrapper/withConfigurationProvider.tsx

@@ -21,13 +21,13 @@ const prepareConfiguration = (
   keys: [string]
 ) => R.compose(R.evolve(keysMap), R.pickAll(keys))(configuration);
 
+const configurationKeys = R.keys(keysMap);
+
 export function withConfigurationProvider(Component: React.ComponentType<any>) {
   return function WithConfigurationProvider(props: Props) {
     const styles = props?.screenData?.styles;
     const general = props?.screenData?.general;
 
-    const configurationKeys = React.useMemo(() => R.keys(keysMap), []);
-
     const configuration = React.useMemo(
       () => prepareConfiguration({ ...general, ...styles }, configurationKeys),
       []

package/Decorators/ZappPipesDataConnector/index.tsx

@@ -1,12 +1,10 @@
 /// <reference types="@applicaster/applicaster-types" />
 /// <reference types="@applicaster/zapp-react-native-ui-components" />
 import React, { useEffect, useMemo } from "react";
-import { localStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/LocalStorage";
 
 import * as R from "ramda";
 import { Platform } from "react-native";
 import Url from "url";
-import { ENDPOINT_TAGS } from "@applicaster/zapp-react-native-utils/types";
 import { favoritesListener } from "@applicaster/zapp-react-native-bridge/Favorites";
 import { usePickFromState } from "@applicaster/zapp-react-native-redux/hooks";
 import { useRoute } from "@applicaster/zapp-react-native-utils/reactHooks/navigation";
@@ -21,12 +19,7 @@ import { ZappPipesSearchContext } from "@applicaster/zapp-react-native-ui-compon
 import { useScreenContext } from "@applicaster/zapp-react-native-utils/reactHooks/screen/useScreenContext";
 
 import { isVerticalListOrGrid } from "./utils";
-import { appStore } from "@applicaster/zapp-react-native-redux/AppStore";
-import {
-  findEndpointForURL,
-  HTTP_METHODS,
-} from "@applicaster/zapp-pipes-v2-client";
-import { getNamespaceAndKey } from "@applicaster/zapp-react-native-utils/appUtils/contextKeysManager/utils";
+import { subscribeForUrlContextKeyChanges } from "@applicaster/zapp-pipes-v2-client";
 
 type Props = {
   component: ZappUIComponent;
@@ -300,27 +293,7 @@ export function zappPipesDataConnector(
           return addListener(reloadData);
         }
       } else {
-        const pipesEndpoints = appStore.get("pipesEndpoints");
-
-        const endpointURL = findEndpointForURL(
-          dataSourceUrl,
-          pipesEndpoints,
-          HTTP_METHODS.GET
-        );
-
-        const endpoint = pipesEndpoints?.[endpointURL];
-
-        if (endpoint?.tags?.includes(ENDPOINT_TAGS.observe_storage)) {
-          const subscriptions: (() => void)[] = endpoint.context_obj.map(
-            (data: Record<string, any>) => {
-              const { namespace, key } = getNamespaceAndKey(data.key);
-
-              return localStorage.addListener({ key, namespace }, reloadData);
-            }
-          );
-
-          return () => subscriptions.forEach((listener) => listener());
-        }
+        return subscribeForUrlContextKeyChanges(dataSourceUrl, {}, reloadData);
       }
     }, [dataSourceUrl, reloadData]);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/zapp-react-native-ui-components",
-  "version": "13.0.0-alpha.8865612391",
+  "version": "13.0.0-alpha.8865907528",
   "description": "Applicaster Zapp React Native ui components for the Quick Brick App",
   "main": "index.js",
   "types": "index.d.ts",
@@ -29,15 +29,13 @@
   },
   "homepage": "https://github.com/applicaster/quickbrick#readme",
   "devDependencies": {
-    "@types/react": "17.0.2",
-    "@types/react-native": "0.69.6",
     "redux-mock-store": "^1.5.3"
   },
   "dependencies": {
-    "@applicaster/applicaster-types": "13.0.0-alpha.8865612391",
-    "@applicaster/zapp-react-native-bridge": "13.0.0-alpha.8865612391",
-    "@applicaster/zapp-react-native-redux": "13.0.0-alpha.8865612391",
-    "@applicaster/zapp-react-native-utils": "13.0.0-alpha.8865612391",
+    "@applicaster/applicaster-types": "13.0.0-alpha.8865907528",
+    "@applicaster/zapp-react-native-bridge": "13.0.0-alpha.8865907528",
+    "@applicaster/zapp-react-native-redux": "13.0.0-alpha.8865907528",
+    "@applicaster/zapp-react-native-utils": "13.0.0-alpha.8865907528",
     "promise": "^8.3.0",
     "react-router-native": "^5.1.2",
     "url": "^0.11.0",
@@ -46,7 +44,6 @@
   "peerDependencies": {
     "@applicaster/zapp-pipes-v2-client": "*",
     "@react-native-community/netinfo": "*",
-    "@types/node": "*",
     "immer": "*",
     "react": "*",
     "react-native": "*",

package/tsconfig.json

@@ -2,8 +2,7 @@
   "extends": "../../tsconfig.base.json",
   "compilerOptions": {
     "outDir": "./lib",
-    "rootDir": "./src"
+    "rootDir": "./"
   },
-  "exclude": ["src/**/*.test.tsx"],
-  "include": ["src/**/*"]
+  "include": ["**/*"],
 }

package/Components/Cell/CellWithFocusable.ios.tsx

@@ -1,126 +0,0 @@
-/** TODO: Remove this file when tvos FocusableGroup
- * behaviour is aligned to the web one
- * FocusableGroup should only send onFocus and onBlur events when
- * Focus enters and leaves the Focusables inside the branch
- */
-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;
-};
-
-type Props = {
-  item: ZappEntry;
-  CellRenderer: React.FunctionComponent<any>;
-  id: string;
-  groupId: string;
-  onFocus: Function;
-  index: number;
-  scrollTo: Function;
-  preferredFocus?: boolean;
-  skipFocusManagerRegistration?: boolean;
-  isFocusable?: boolean;
-  behavior: Behavior;
-  focused?: boolean;
-};
-
-export function CellWithFocusable(props: Props) {
-  const {
-    index,
-    item,
-    CellRenderer,
-    id,
-    groupId,
-    onFocus,
-    scrollTo = noop,
-    preferredFocus,
-    skipFocusManagerRegistration,
-    isFocusable,
-    behavior,
-    focused,
-  } = props;
-
-  const isFocused = useCellFocusedState(
-    skipFocusManagerRegistration,
-    groupId,
-    id
-  );
-
-  const state = useCellState({
-    id: item.id,
-    behavior,
-    focused: isFocused || toBooleanWithDefaultFalse(focused),
-  });
-
-  const [focusedButtonId, setFocusedButtonId] = React.useState(undefined);
-
-  // for horizontal scrolling
-  React.useEffect(() => {
-    if (focusedButtonId) {
-      scrollTo(index);
-    }
-  }, [focusedButtonId]);
-
-  const handleToggleFocus = (value) => {
-    setFocusedButtonId(value.focusedButtonId);
-
-    if (value.focusable) {
-      onFocus(value.focusable, value.mouse);
-    }
-  };
-
-  return (
-    <CellRenderer
-      item={item}
-      groupId={groupId}
-      onToggleFocus={handleToggleFocus}
-      state={state}
-      prefixId={id}
-      focusedButtonId={focusedButtonId}
-      preferredFocus={preferredFocus}
-      skipFocusManagerRegistration={skipFocusManagerRegistration}
-      isFocusable={isFocusable}
-      focused={focused}
-    />
-  );
-}