@applicaster/zapp-react-native-ui-components 16.0.0-alpha.1740103407 → 16.0.0-alpha.1803625751

package/Components/GeneralContentScreen/hookAdapter/validationHelper.ts

@@ -0,0 +1,72 @@
+import { getNamespaceAndKey } from "@applicaster/zapp-react-native-utils/appUtils/contextKeysManager/utils";
+import { localStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/LocalStorage";
+import { sessionStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/SessionStorage";
+import { log_error, log_info } from "./logger";
+
+type ParseKey = { key: string; namespace?: string };
+
+export function parseKeyEntries(input: string): ParseKey[] {
+  return input.split(",").flatMap((item) => {
+    const trimmed = item.trim();
+
+    return trimmed ? getNamespaceAndKey(trimmed) : [];
+  });
+}
+
+export const getKeyToSkipHook = async (key: string, namespace?: string) => {
+  const value = await sessionStorage.getItem(key, namespace);
+
+  if (value) {
+    return value;
+  }
+
+  return await localStorage.getItem(key, namespace);
+};
+
+export const shouldSkipHook = async (
+  skipHookIfKeysExist?: string
+): Promise<boolean> => {
+  if (!skipHookIfKeysExist?.trim()) {
+    log_info("shouldSkipHook: No skipping condition provided");
+
+    return false;
+  }
+
+  const keyEntries = parseKeyEntries(skipHookIfKeysExist);
+
+  if (keyEntries.length === 0) {
+    log_info("shouldSkipHook: No valid keys provided");
+
+    return false;
+  }
+
+  for (const entry of keyEntries) {
+    try {
+      const value = await getKeyToSkipHook(entry.key, entry.namespace);
+
+      if (value) {
+        log_info(
+          `shouldSkipHook: Hook will be skipped due to: ${
+            entry.namespace ?? ""
+          } ${entry.key}. Finishing hook flow`
+        );
+
+        return true;
+      }
+    } catch (error) {
+      log_error(
+        `shouldSkipHook: Error: ${error.message} checking key: ${
+          entry.namespace ?? ""
+        } ${entry.key}`,
+        { error }
+      );
+    }
+  }
+
+  log_info(
+    // eslint-disable-next-line max-len
+    "shouldSkipHook: No skipping condition met, none of the provided keys found in storage, proceeding with hook"
+  );
+
+  return false;
+};

package/Components/GeneralContentScreen/hookFocus/index.tsx

@@ -0,0 +1,13 @@
+import * as React from "react";
+
+type Props = {
+  children: React.ReactElement;
+};
+
+/**
+ * On native platforms the river `ComponentsMap` registers its own initial focus,
+ * so a hook-presented general content screen needs no extra focus wrapper here.
+ * The web counterpart (`index.web.tsx`) recreates the content focus group that
+ * the `River` wrapper would normally provide.
+ */
+export const HookContentFocusGroup = ({ children }: Props) => <>{children}</>;

package/Components/GeneralContentScreen/hookFocus/index.web.tsx

@@ -0,0 +1,69 @@
+import * as React from "react";
+import { StyleSheet } from "react-native";
+import { shallow } from "zustand/shallow";
+
+import { FocusableGroup } from "../../FocusableGroup";
+import {
+  useContentId,
+  useNavbarId,
+  usePathname,
+} from "@applicaster/zapp-react-native-utils/reactHooks/navigation";
+import { useZappHookModalStore } from "../../../Contexts/ZappHookModalContext";
+
+import { useInitialFocus } from "../../Screen/TV/hooks";
+
+const styles = StyleSheet.create({
+  container: { flex: 1 },
+});
+
+type Props = {
+  children: React.ReactElement;
+};
+
+/**
+ * A general content screen presented as a full-screen hook is rendered straight
+ * through `ComponentsMap`, bypassing the web `River` wrapper. That wrapper is what
+ * normally creates the `quick-brick-content` FocusableGroup (with `preferredFocus`)
+ * the focus manager relies on and what lets initial focus land on the content.
+ *
+ * Without it the hook screen renders but nothing is focusable on web TV. This
+ * recreates that content group and triggers initial focus, mirroring `River`.
+ */
+const FocusedHookContent = ({ children }: Props) => {
+  const contentId = useContentId();
+  const navbarId = useNavbarId();
+  const pathname = usePathname();
+
+  useInitialFocus();
+
+  return (
+    <FocusableGroup
+      id={contentId}
+      // Nest under the hook-modal route so the focus manager treats this as the
+      // active screen's content node; `useInitialFocus` targets the same route.
+      groupId={pathname}
+      nextFocusUp={navbarId}
+      preferredFocus
+      shouldUsePreferredFocus
+      style={styles.container}
+    >
+      {React.cloneElement(children, { groupId: contentId })}
+    </FocusableGroup>
+  );
+};
+
+export const HookContentFocusGroup = ({ children }: Props) => {
+  const isRunningInBackground = useZappHookModalStore(
+    (state) => state.isRunningInBackground,
+    shallow
+  );
+
+  // A hook presented full screen (either as a `/hooks/<id>` screen or a
+  // full-screen modal) needs the content focus group. Only background runs,
+  // which render invisibly, must be left alone so they don't steal focus.
+  if (isRunningInBackground) {
+    return <>{children}</>;
+  }
+
+  return <FocusedHookContent>{children}</FocusedHookContent>;
+};

package/Components/GeneralContentScreen/index.ts

@@ -1 +1,3 @@
 export { GeneralContentScreen } from "./GeneralContentScreen";
+
+export { GeneralContentScreenHookAdapter } from "./GeneralContentScreenHookAdapter";

package/Components/MasterCell/DefaultComponents/ActionButtonsCore/__tests__/placement.test.ts

@@ -6,28 +6,54 @@ import {
 describe("ActionButtonsCore placement", () => {
   const buttons = { type: "View", name: "buttons" };
 
-  const above_labels = [
-    { name: "above_label_1" },
-    { name: "above_label_2" },
-    { name: "above_label_3" },
+  const slots = [
+    { name: "text_label_1", element: { type: "View", id: "label_1" } },
+    { name: "text_label_2", element: { type: "View", id: "label_2" } },
+    { name: "text_label_3", element: { type: "View", id: "label_3" } },
   ];
 
-  const below_labels = [
-    { name: "below_label_1" },
-    { name: "below_label_2" },
-    { name: "below_label_3" },
-  ];
+  const labels = slots.map((slot) => slot.element);
 
   it("inserts buttons after the matching label", () => {
     expect(
-      insertBetweenLabels({ position: "below_label_2" }, buttons, below_labels)
-    ).toEqual([below_labels[0], below_labels[1], buttons, below_labels[2]]);
+      insertBetweenLabels({ position: "below_text_label_2" }, buttons, slots)
+    ).toEqual([labels[0], labels[1], buttons, labels[2]]);
   });
 
   it("inserts buttons before the matching label", () => {
     expect(
-      insertBetweenLabels({ position: "above_label_2" }, buttons, above_labels)
-    ).toEqual([above_labels[0], buttons, above_labels[1], above_labels[2]]);
+      insertBetweenLabels({ position: "above_text_label_2" }, buttons, slots)
+    ).toEqual([labels[0], buttons, labels[1], labels[2]]);
+  });
+
+  it("inserts buttons after the matching label on a plain name match", () => {
+    expect(
+      insertBetweenLabels({ position: "text_label_2" }, buttons, slots)
+    ).toEqual([labels[0], labels[1], buttons, labels[2]]);
+  });
+
+  it("keeps the slot when its label is empty (null element)", () => {
+    const slotsWithEmpty = [
+      { name: "text_label_1", element: { id: "label_1" } },
+      { name: "text_label_2", element: null },
+      { name: "text_label_3", element: { id: "label_3" } },
+    ];
+
+    expect(
+      insertBetweenLabels(
+        { position: "above_text_label_2" },
+        buttons,
+        slotsWithEmpty
+      )
+    ).toEqual([{ id: "label_1" }, buttons, { id: "label_3" }]);
+
+    expect(
+      insertBetweenLabels(
+        { position: "below_text_label_2" },
+        buttons,
+        slotsWithEmpty
+      )
+    ).toEqual([{ id: "label_1" }, buttons, { id: "label_3" }]);
   });
 
   it("prepends buttons only when on_top is allowed", () => {
@@ -35,17 +61,17 @@ describe("ActionButtonsCore placement", () => {
       insertBetweenLabels(
         { position: "on_top", allowOnTop: true },
         buttons,
-        below_labels
+        slots
       )
-    ).toEqual([buttons, ...below_labels]);
+    ).toEqual([buttons, ...labels]);
 
     expect(
       insertBetweenLabels(
         { position: "on_top", allowOnTop: false },
         buttons,
-        below_labels
+        slots
       )
-    ).toEqual(below_labels);
+    ).toEqual(labels);
   });
 
   it("appends buttons when appendWhenMissing is enabled", () => {
@@ -53,9 +79,9 @@ describe("ActionButtonsCore placement", () => {
       insertBetweenLabels(
         { position: "unknown", appendWhenMissing: true },
         buttons,
-        below_labels
+        slots
       )
-    ).toEqual([...below_labels, buttons]);
+    ).toEqual([...labels, buttons]);
   });
 
   it("returns labels unchanged when appendWhenMissing is disabled", () => {
@@ -63,9 +89,9 @@ describe("ActionButtonsCore placement", () => {
       insertBetweenLabels(
         { position: "unknown", appendWhenMissing: false },
         buttons,
-        below_labels
+        slots
       )
-    ).toEqual(below_labels);
+    ).toEqual(labels);
   });
 
   const labelContainers = [

package/Components/MasterCell/DefaultComponents/ActionButtonsCore/placement.ts

@@ -17,6 +17,11 @@ type InsertOptions = {
   appendWhenMissing?: boolean;
 };
 
+type Slot = {
+  name: string;
+  element?: unknown;
+};
+
 const hasLabelName = (value: unknown): value is Label =>
   !!value &&
   typeof value === "object" &&
@@ -100,8 +105,14 @@ const containsNestedLabel = (
 export const insertBetweenLabels = (
   { position, allowOnTop = false, appendWhenMissing = false }: InsertOptions,
   buttons: unknown,
-  labels: Label[] = []
+  slots: Slot[] = []
 ) => {
+  // Slots are defined by the canonical label list, so an empty (null) label
+  // still keeps its position — buttons placed above/below it survive.
+  const labels = slots
+    .map((slot) => slot.element)
+    .filter((element) => element != null);
+
   if (buttons == null) {
     return labels;
   }
@@ -110,14 +121,31 @@ export const insertBetweenLabels = (
     return [buttons, ...labels];
   }
 
-  const labelsWithButtons = withButtons(position, buttons, labels);
-  const inserted = labelsWithButtons.length !== labels.length;
+  let inserted = false;
+  const result: unknown[] = [];
+
+  for (const { name, element } of slots) {
+    if (position === `above_${name}`) {
+      result.push(buttons);
+      inserted = true;
+    }
+
+    if (element != null) {
+      result.push(element);
+    }
+
+    // Insert after on `below_*` or a plain label-name match.
+    if (position === `below_${name}` || position === name) {
+      result.push(buttons);
+      inserted = true;
+    }
+  }
 
-  if (!inserted && appendWhenMissing) {
-    return [...labels, buttons];
+  if (!inserted) {
+    return appendWhenMissing ? [...labels, buttons] : labels;
   }
 
-  return inserted ? labelsWithButtons : [...labels];
+  return result;
 };
 
 export const insertBetweenLabelContainers = (

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

@@ -1,13 +1,14 @@
-import React from "react";
+import React, { PropsWithChildren } from "react";
 import { isVideoPreviewEnabled } from "@applicaster/zapp-react-native-ui-components/Components/MasterCell/utils";
 import { LiveImage } from "../LiveImage";
 import PureImage from "../Image";
 import { useIsScreenActive } from "@applicaster/zapp-react-native-utils/reactHooks";
 
-type Props = {
+type Props = PropsWithChildren<{
   enable_video_preview: boolean;
   player_screen_id: string;
-};
+  uri?: string;
+}>;
 
 export const ImageContainer = (props: Props) => {
   const isActive = useIsScreenActive();

package/Components/MasterCell/DefaultComponents/PressableView.tsx

@@ -1,9 +1,9 @@
 import React from "react";
-import { TouchableOpacity } from "react-native";
+import { TouchableOpacity, ViewStyle } from "react-native";
 
 type Props = {
   children?: React.ReactNode;
-  style?: Record<string, unknown>;
+  style?: ViewStyle | ViewStyle[];
   testID?: string;
   accessibilityLabel?: string;
   accessibilityHint?: string;
@@ -12,7 +12,7 @@ type Props = {
 
 export function PressableView({
   children,
-  style = {},
+  style,
   testID,
   accessibilityLabel,
   accessibilityHint,

package/Components/MasterCell/DefaultComponents/mobile/MobileActionButtons/ActionButton.tsx

@@ -1,4 +1,5 @@
 import React from "react";
+import { StyleSheet, View, ViewStyle } from "react-native";
 import { PressableView } from "../../PressableView";
 
 import { ActionButtonController } from "../../ActionButtonsCore/components";
@@ -15,6 +16,22 @@ type ChildElementProps = {
   entry?: any;
 };
 
+const styles = StyleSheet.create({
+  pressableView: {
+    overflow: "hidden",
+    flexDirection: "row",
+  },
+  maxWidthFull: {
+    width: "100%",
+  },
+  innerWrapper: {
+    flexDirection: "row",
+    flexGrow: 0,
+    flexShrink: 1,
+    overflow: "hidden",
+  },
+});
+
 const isValidElement = (
   child: React.ReactNode
 ): child is React.ReactElement<ChildElementProps> =>
@@ -121,12 +138,31 @@ export const ActionButton = ({ style, children, action, entry, ...props }) => {
         return (
           <PressableView
             testID={props.testID || `${entry?.id}`}
-            style={isActive ? { ...style, ...props.focusedStyles } : style}
+            style={[
+              isActive
+                ? {
+                    ...(style as ViewStyle),
+                    ...(props.focusedStyles as ViewStyle),
+                  }
+                : (style as ViewStyle),
+              styles.pressableView,
+            ]}
             onPress={onPress}
             accessibilityLabel={props.accessibilityLabel || `${entry?.id}`}
             accessibilityHint={props.accessibilityHint}
           >
-            {_cloneChildrenWithState(children)}
+            <View
+              style={{
+                maxWidth: (style as ViewStyle).maxWidth,
+                ...((style as ViewStyle).maxWidth
+                  ? styles.maxWidthFull
+                  : undefined),
+              }}
+            >
+              <View style={[styles.innerWrapper, props.alignment]}>
+                {_cloneChildrenWithState(children)}
+              </View>
+            </View>
           </PressableView>
         );
       }}

package/Components/MasterCell/DefaultComponents/mobile/MobileActionButtons/AssetComponent.tsx

@@ -1,5 +1,5 @@
 import React from "react";
-import { View } from "react-native";
+import { StyleSheet, View } from "react-native";
 import { ImageContainer } from "../../ImageContainer";
 
 type Props = {
@@ -10,13 +10,24 @@ type Props = {
   cellUUID?: string;
 };
 
+const styles = StyleSheet.create({
+  assetContainer: {
+    flexShrink: 0,
+    justifyContent: "center",
+    alignItems: "center",
+  },
+});
+
 export const AssetComponent = (props: Props & Record<string, unknown>) => {
   return props.asset && React.isValidElement(props.asset) ? (
-    <View style={props.style} testID={props.testID}>
+    <View style={[styles.assetContainer, props.style]} testID={props.testID}>
       {React.cloneElement(props.asset, { cellUUID: props.cellUUID })}
     </View>
   ) : (
-    // @ts-ignore
-    <ImageContainer {...props} uri={props.uri} />
+    <ImageContainer
+      style={[styles.assetContainer, props.style]}
+      {...(props as any)}
+      uri={props.uri}
+    />
   );
 };

package/Components/MasterCell/DefaultComponents/mobile/MobileActionButtons/Button.ts

@@ -10,23 +10,33 @@ import {
   getPressableStyles,
   getTextLabelStyles,
 } from "./utils";
+import { ViewStyle } from "react-native";
 
 const displayModeStyle = (value) => {
   const mode = value("display_mode") || "dynamic";
 
-  if (mode === "fixed") {
-    return {
-      width: toNumberWithDefault(140, value("width")),
-    };
-  }
+  const defaultStyle = {
+    flexShrink: 1,
+  };
 
-  if (mode === "fill") {
-    return {
-      flex: 1,
-    };
+  switch (mode) {
+    case "fixed":
+      return {
+        ...defaultStyle,
+        width: toNumberWithDefault(140, value("width")),
+        maxWidth: toNumberWithDefault(140, value("width")),
+      };
+    case "fill":
+      return {
+        ...defaultStyle,
+        flex: 1,
+      };
+    case "dynamic":
+    default:
+      return {
+        ...defaultStyle,
+      };
   }
-
-  return {};
 };
 
 type Props = {
@@ -34,7 +44,7 @@ type Props = {
   value: Function;
   stylePrefix: string;
   specificPrefix: string;
-  spacingStyle: Record<string, unknown>;
+  spacingStyle: ViewStyle;
 };
 
 export const Button = ({
@@ -75,14 +85,17 @@ export const Button = ({
     type: "MobileActionButton",
     style: {
       flexDirection: getContentDirection(assetAlignment),
-      alignContent: "center",
-      alignItems: getContentsAlignment(contentsAlignment, assetAlignment),
-      justifyContent: getContentsAlignment(contentsAlignment, assetAlignment),
+      // alignContent: "center", Why do we need this?
       ...getPressableStyles(getValue),
       ...displayModeStyle(getValue),
       ...spacingStyle,
     },
     additionalProps: {
+      alignment: {
+        alignContent: "center",
+        alignItems: getContentsAlignment(contentsAlignment, assetAlignment),
+        justifyContent: getContentsAlignment(contentsAlignment, assetAlignment),
+      },
       action: {
         identifier: actionIdentifier,
         flavour: actionAssetFlavour,
@@ -114,7 +127,8 @@ export const Button = ({
                 color: getValue("focused_font_color"),
               },
               transformText: getValue("text_transform") || "default",
-              numberOfLines: getValue("number_of_lines"),
+              numberOfLines: getValue("number_of_lines") || 1,
+              ellipseMode: "tail",
             },
             actionIdentifier,
             testID,

package/Components/MasterCell/DefaultComponents/mobile/MobileActionButtons/TextLabelsContainer.ts

@@ -14,6 +14,9 @@ export const TextLabelsContainer = ({
 }: Props) => {
   return {
     type: "View",
+    style: {
+      flexShrink: 1,
+    },
     additionalProps: {
       mobileActionRole: "label_container",
     },

package/Components/MasterCell/DefaultComponents/mobile/MobileActionButtons/index.ts

@@ -6,6 +6,7 @@ import {
 } from "./utils";
 import { Button } from "./Button";
 import { buildActionButtonsModel } from "../../ActionButtonsCore/model";
+import { ViewStyle } from "react-native";
 
 const CONTAINER_PREFIX = "mobile_buttons_container";
 const BUTTON_PREFIX = "mobile_button";
@@ -81,7 +82,7 @@ export const MobileActionButtons = ({
       const isVertical = stacking === "vertical";
       const gutter = isVertical ? verticalGutter : horizontalGutter;
 
-      const spacingStyle = {
+      const spacingStyle: ViewStyle = {
         [isVertical ? "marginBottom" : "marginRight"]: isNotLast ? gutter : 0,
       };
 

package/Components/MasterCell/DefaultComponents/mobile/MobileActionButtons/utils/__tests__/insertButtons.test.ts

@@ -5,14 +5,19 @@ import {
 } from "..";
 
 describe("mobile action insertion helpers", () => {
-  const labels = [{ name: "text_label_1" }, { name: "text_label_2" }];
+  const slots = [
+    { name: "text_label_1", element: { type: "View", id: "text_label_1" } },
+    { name: "text_label_2", element: { type: "View", id: "text_label_2" } },
+  ];
+
+  const labels = slots.map((slot) => slot.element);
   const buttons = { type: "View", name: "buttons" };
 
   it("inserts label buttons below target label", () => {
     const result = insertButtonsBetweenLabels(
       { mobile_buttons_container_position: "below_text_label_1" },
       buttons,
-      labels
+      slots
     );
 
     expect(result).toEqual([labels[0], buttons, labels[1]]);
@@ -22,7 +27,7 @@ describe("mobile action insertion helpers", () => {
     const result = insertButtonsBetweenLabels(
       { mobile_buttons_container_position: "unknown" },
       buttons,
-      labels
+      slots
     );
 
     expect(result).toEqual([labels[0], labels[1]]);

package/Components/MasterCell/DefaultComponents/mobile/MobileActionButtons/utils/index.ts

@@ -8,7 +8,7 @@ import { Platform } from "react-native";
 export const insertButtonsBetweenLabels = (
   configuration: Record<string, unknown>,
   buttons,
-  labels = []
+  slots = [] // { name, element } per canonical text label slot
 ) =>
   insertBetweenLabels(
     {
@@ -19,7 +19,7 @@ export const insertButtonsBetweenLabels = (
       appendWhenMissing: false,
     },
     buttons,
-    labels // "text_label_1", "text_label_2", "text_label_3", "text_label_4"
+    slots
   );
 
 export const insertButtonsBetweenLabelContainers = (