@applicaster/zapp-react-native-utils 14.0.0-rc.9 → 15.0.0-alpha.1089439460

package/configurationUtils/__tests__/manifestKeyParser.test.ts

@@ -0,0 +1,546 @@
+import { getAllSpecificStyles } from "../manifestKeyParser";
+
+jest.mock("@applicaster/zapp-react-native-utils/reactUtils", () => ({
+  platformSelect: jest.fn((platforms) => platforms.samsung_tv), // Default to samsung for tests
+}));
+
+jest.mock("@applicaster/zapp-react-native-utils/stringUtils", () => ({
+  toCamelCase: jest.fn((str: string) => {
+    // Simple camelCase implementation for testing
+    return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+  }),
+}));
+
+describe("getAllSpecificStyles", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe("Basic functionality", () => {
+    it("should throw error if outStyles is not provided", () => {
+      expect(() => {
+        getAllSpecificStyles({
+          componentName: "button",
+          subComponentName: "",
+          configuration: {},
+          outStyles: null as any,
+        });
+      }).toThrow("outStyles is required");
+    });
+
+    it("should throw error if componentName is not provided", () => {
+      expect(() => {
+        getAllSpecificStyles({
+          componentName: "",
+          subComponentName: "",
+          configuration: {},
+          outStyles: {},
+        });
+      }).toThrow("componentName is required");
+    });
+
+    it("should initialize default key if not present", () => {
+      const outStyles = {};
+
+      getAllSpecificStyles({
+        componentName: "button",
+        subComponentName: "",
+        configuration: {},
+        outStyles,
+      });
+
+      expect(outStyles).toHaveProperty("default");
+      expect(outStyles["default"]).toEqual({});
+    });
+
+    it("should handle empty configuration", () => {
+      const outStyles = { default: {} };
+
+      getAllSpecificStyles({
+        componentName: "button",
+        subComponentName: "",
+        configuration: {},
+        outStyles,
+      });
+
+      expect(outStyles).toEqual({ default: {} });
+    });
+  });
+
+  describe("Style name parsing", () => {
+    it("should parse basic style without state or platform", () => {
+      const outStyles = {};
+
+      const configuration = {
+        button_style_background_color: "#FF0000",
+        button_style_border_width: 2,
+      };
+
+      getAllSpecificStyles({
+        componentName: "button",
+        subComponentName: "",
+        configuration,
+        outStyles,
+      });
+
+      expect(outStyles["default"]).toEqual({
+        backgroundColor: "#FF0000",
+        borderWidth: 2,
+      });
+    });
+
+    it("should handle subComponentName correctly", () => {
+      const outStyles = {};
+
+      const configuration = {
+        player_controls_style_button_background_color: "#FF0000",
+        player_controls_style_button_text_size: 16,
+      };
+
+      getAllSpecificStyles({
+        componentName: "player_controls",
+        subComponentName: "button",
+        configuration,
+        outStyles,
+      });
+
+      expect(outStyles["default"]).toEqual({
+        backgroundColor: "#FF0000",
+        textSize: 16,
+      });
+    });
+
+    it("should ignore keys that do not match the prefix", () => {
+      const outStyles = {};
+
+      const configuration = {
+        button_style_background_color: "#FF0000",
+        other_component_style_text_color: "#00FF00", // Should be ignored
+        random_key: "value", // Should be ignored
+      };
+
+      getAllSpecificStyles({
+        componentName: "button",
+        subComponentName: "",
+        configuration,
+        outStyles,
+      });
+
+      expect(outStyles["default"]).toEqual({
+        backgroundColor: "#FF0000",
+      });
+    });
+  });
+
+  describe("State handling", () => {
+    it("should handle pressed state", () => {
+      const outStyles = {};
+
+      const configuration = {
+        button_style_background_color: "#FF0000",
+        button_style_pressed_background_color: "#00FF00",
+      };
+
+      getAllSpecificStyles({
+        componentName: "button",
+        subComponentName: "",
+        configuration,
+        outStyles,
+      });
+
+      expect(outStyles["default"]).toEqual({
+        backgroundColor: "#FF0000",
+      });
+
+      expect(outStyles["pressed"]).toEqual({
+        backgroundColor: "#00FF00",
+      });
+    });
+
+    it("should handle focused state", () => {
+      const outStyles = {};
+
+      const configuration = {
+        button_style_focused_border_width: 3,
+      };
+
+      getAllSpecificStyles({
+        componentName: "button",
+        subComponentName: "",
+        configuration,
+        outStyles,
+      });
+
+      expect(outStyles["focused"]).toEqual({
+        borderWidth: 3,
+      });
+    });
+
+    it("should handle selected state", () => {
+      const outStyles = {};
+
+      const configuration = {
+        button_style_selected_opacity: 0.5,
+      };
+
+      getAllSpecificStyles({
+        componentName: "button",
+        subComponentName: "",
+        configuration,
+        outStyles,
+      });
+
+      expect(outStyles["selected"]).toEqual({
+        opacity: 0.5,
+      });
+    });
+
+    it("should handle focused_selected state", () => {
+      const outStyles = {};
+
+      const configuration = {
+        button_style_focused_selected_scale: 1.2,
+      };
+
+      getAllSpecificStyles({
+        componentName: "button",
+        subComponentName: "",
+        configuration,
+        outStyles,
+      });
+
+      expect(outStyles["focused_selected"]).toEqual({
+        scale: 1.2,
+      });
+    });
+
+    it("should merge default styles into other states", () => {
+      const outStyles = {};
+
+      const configuration = {
+        button_style_background_color: "#FF0000",
+        button_style_border_width: 1,
+        button_style_opacity: 1,
+        button_style_pressed_background_color: "#00FF00",
+        button_style_focused_opacity: 0.8,
+      };
+
+      getAllSpecificStyles({
+        componentName: "button",
+        subComponentName: "",
+        configuration,
+        outStyles,
+      });
+
+      expect(outStyles["default"]).toEqual({
+        backgroundColor: "#FF0000",
+        borderWidth: 1,
+        opacity: 1,
+      });
+
+      // Pressed should have default styles merged with its specific override
+      expect(outStyles["pressed"]).toEqual({
+        backgroundColor: "#00FF00", // Override
+        borderWidth: 1, // From default
+        opacity: 1, // From default
+      });
+
+      // Focused should have default styles merged with its specific override
+      expect(outStyles["focused"]).toEqual({
+        backgroundColor: "#FF0000", // From default
+        borderWidth: 1, // From default
+        opacity: 0.8, // Override
+      });
+    });
+
+    it("should preserve existing state values when merging", () => {
+      const outStyles = {
+        pressed: { existingKey: "existingValue" },
+      };
+
+      const configuration = {
+        button_style_background_color: "#FF0000",
+        button_style_pressed_text_color: "#FFFFFF",
+      };
+
+      getAllSpecificStyles({
+        componentName: "button",
+        subComponentName: "",
+        configuration,
+        outStyles,
+      });
+
+      expect(outStyles["pressed"]).toEqual({
+        existingKey: "existingValue", // Should be preserved
+        backgroundColor: "#FF0000", // From default
+        textColor: "#FFFFFF", // New pressed style
+      });
+    });
+  });
+
+  describe("Platform handling", () => {
+    it("should include styles for current platform (samsung)", () => {
+      const outStyles = {};
+
+      const configuration = {
+        button_style_samsung_background_color: "#FF0000",
+        button_style_background_color: "#00FF00",
+      };
+
+      getAllSpecificStyles({
+        componentName: "button",
+        subComponentName: "",
+        configuration,
+        outStyles,
+      });
+
+      expect(outStyles["default"]).toEqual({
+        backgroundColor: "#FF0000", // Samsung-specific should be included
+      });
+    });
+
+    it("should skip styles for other platforms", () => {
+      const outStyles = {};
+
+      const configuration = {
+        button_style_ios_background_color: "#FF0000",
+        button_style_android_text_color: "#00FF00",
+        button_style_tvos_border_width: 2,
+        button_style_lg_opacity: 0.5,
+        button_style_background_color: "#FFFFFF",
+      };
+
+      getAllSpecificStyles({
+        componentName: "button",
+        subComponentName: "",
+        configuration,
+        outStyles,
+      });
+
+      expect(outStyles["default"]).toEqual({
+        backgroundColor: "#FFFFFF", // Only non-platform specific
+      });
+    });
+
+    it("should handle platform in middle of style name", () => {
+      const outStyles = {};
+
+      const configuration = {
+        button_style_text_samsung_color: "#FF0000",
+      };
+
+      getAllSpecificStyles({
+        componentName: "button",
+        subComponentName: "text",
+        configuration,
+        outStyles,
+      });
+
+      expect(outStyles["default"]).toEqual({
+        color: "#FF0000",
+      });
+    });
+
+    it("should handle platform-specific styles with states", () => {
+      const outStyles = {};
+
+      const configuration = {
+        button_style_samsung_pressed_background_color: "#FF0000",
+        button_style_ios_pressed_background_color: "#00FF00", // Should be ignored
+      };
+
+      getAllSpecificStyles({
+        componentName: "button",
+        subComponentName: "",
+        configuration,
+        outStyles,
+      });
+
+      expect(outStyles["pressed"]).toEqual({
+        backgroundColor: "#FF0000", // Only samsung style
+      });
+    });
+
+    it("should work correctly when platform is Samsung", () => {
+      const outStyles = {};
+
+      const configuration = {
+        button_style_ios_background_color: "#FF0000",
+        button_style_samsung_background_color: "#00FF00",
+        button_style_background_color: "#FFFFFF",
+      };
+
+      getAllSpecificStyles({
+        componentName: "button",
+        subComponentName: "",
+        configuration,
+        outStyles,
+      });
+
+      expect(outStyles["default"]).toEqual({
+        backgroundColor: "#00FF00", // Samsung-specific should win
+      });
+    });
+  });
+
+  describe("Complex scenarios", () => {
+    it("should handle multiple states and platforms correctly", () => {
+      const outStyles = {};
+
+      const configuration = {
+        // Default styles
+        button_style_background_color: "#FFFFFF",
+        button_style_text_color: "#000000",
+        button_style_border_width: 1,
+
+        // Platform-specific default
+        button_style_samsung_padding: 10,
+
+        // State-specific
+        button_style_pressed_background_color: "#EEEEEE",
+        button_style_focused_scale: 1.1,
+
+        // Platform + state specific
+        button_style_samsung_pressed_opacity: 0.8,
+        button_style_ios_pressed_opacity: 0.6, // Should be ignored
+      };
+
+      getAllSpecificStyles({
+        componentName: "button",
+        subComponentName: "",
+        configuration,
+        outStyles,
+      });
+
+      expect(outStyles["default"]).toEqual({
+        backgroundColor: "#FFFFFF",
+        textColor: "#000000",
+        borderWidth: 1,
+        padding: 10,
+      });
+
+      expect(outStyles["pressed"]).toEqual({
+        backgroundColor: "#EEEEEE",
+        textColor: "#000000",
+        borderWidth: 1,
+        padding: 10,
+        opacity: 0.8,
+      });
+
+      expect(outStyles["focused"]).toEqual({
+        backgroundColor: "#FFFFFF",
+        textColor: "#000000",
+        borderWidth: 1,
+        padding: 10,
+        scale: 1.1,
+      });
+    });
+
+    it("should handle edge case keys correctly", () => {
+      const outStyles = {};
+
+      const configuration = {
+        button_style_: "shouldBeIgnored", // Empty style name
+        button_style_samsung_: "shouldBeIgnored", // Platform but no style
+        button_style__pressed: "shouldBeIgnored", // No style name before state
+        button_style_valid_key: "included",
+      };
+
+      getAllSpecificStyles({
+        componentName: "button",
+        subComponentName: "",
+        configuration,
+        outStyles,
+      });
+
+      expect(outStyles["default"]).toEqual({
+        validKey: "included",
+      });
+    });
+
+    it("should handle all state suffixes in priority order", () => {
+      const outStyles = {};
+
+      const configuration = {
+        // Test that focused_selected is recognized before focused
+        button_style_focused_selected_test: "focused_selected_value",
+        button_style_focused_another: "focused_value",
+      };
+
+      getAllSpecificStyles({
+        componentName: "button",
+        subComponentName: "",
+        configuration,
+        outStyles,
+      });
+
+      expect(outStyles["focused_selected"]).toEqual({
+        test: "focused_selected_value",
+      });
+
+      expect(outStyles["focused"]).toEqual({
+        another: "focused_value",
+      });
+    });
+  });
+
+  describe("Immutability", () => {
+    it("should not mutate configuration object", () => {
+      const configuration = Object.freeze({
+        button_style_background_color: "#FF0000",
+      });
+
+      const outStyles = {};
+
+      expect(() => {
+        getAllSpecificStyles({
+          componentName: "button",
+          subComponentName: "",
+          configuration,
+          outStyles,
+        });
+      }).not.toThrow();
+    });
+
+    it("platform pressed overrides generic pressed for same key", () => {
+      const outStyles = {};
+
+      const configuration = {
+        button_style_pressed_background_color: "#111111", // generic
+        button_style_samsung_pressed_background_color: "#222222", // platform
+      };
+
+      getAllSpecificStyles({
+        componentName: "button",
+        subComponentName: "",
+        configuration,
+        outStyles,
+      });
+
+      expect(outStyles["pressed"]["backgroundColor"]).toBe("#222222");
+    });
+
+    it("should handle frozen outStyles properties", () => {
+      const outStyles = {
+        default: Object.freeze({ existingProp: "value" }),
+      };
+
+      const configuration = {
+        button_style_background_color: "#FF0000",
+      };
+
+      getAllSpecificStyles({
+        componentName: "button",
+        subComponentName: "",
+        configuration,
+        outStyles,
+      });
+
+      // Should create new object instead of mutating frozen one
+      expect(outStyles["default"]).toEqual({
+        existingProp: "value",
+        backgroundColor: "#FF0000",
+      });
+    });
+  });
+});

package/configurationUtils/index.ts

@@ -1,6 +1,12 @@
 /// <reference types="@applicaster/applicaster-types" />
 import * as R from "ramda";
 import { Platform } from "react-native";
+import {
+  isFilledArray,
+  isEmptyArray,
+} from "@applicaster/zapp-react-native-utils/arrayUtils";
+import { isEmpty } from "@applicaster/zapp-react-native-utils/utils";
+
 import { applyTransform } from "../transform";
 import { ManifestField } from "../types";
 import { isNilOrEmpty } from "../reactUtils/helpers";
@@ -122,54 +128,77 @@ export function flattenFields(
 }
 
 /**
- * Retrieves the value of the "src" in the first media_item
- * that has the matching key provided in args.
- * Fallbacks: "image_base" key, or first media_item that has any "src"
- * @param {Object} entry    Single entry from a feed
- * @param {Array} arg      Array with a single element - the key of the media item
- *                          from which the "src" should be retrieved
- * @returns {?String}       Value of "src", usually a URI
+ * Retrieves all media items from the entry's media_group that are of type "image" or "thumbnail".
+ *
+ * @param {ZappEntry} entry - The entry object containing the media_group array.
+ * @returns {Option<ZappMediaItem[]>} An array of media items of type "image" or "thumbnail", or undefined if no media_group is present.
+ */
+export function getMediaItems(entry: ZappEntry): Option<ZappMediaItem[]> {
+  const mediaGroup = entry?.media_group || [];
+
+  if (isEmptyArray(mediaGroup)) {
+    return undefined;
+  }
+
+  const mediaItems = mediaGroup
+    .filter((group) => ["image", "thumbnail"].includes(group.type))
+    .flatMap((group) =>
+      Array.isArray(group.media_item) ? group.media_item : [group.media_item]
+    );
+
+  if (isFilledArray(mediaItems)) {
+    return mediaItems;
+  }
+
+  return undefined;
+}
+
+/**
+ * Retrieves the "src" value from a media item in the entry's media group,
+ * based on a provided key, with fallback logic.
+ *
+ * Fallback order:
+ *   1. Attempts to find a media item with the specified key (or "image_base" if none provided).
+ *   2. If not found, attempts to find a media item with the key "image_base".
+ *   3. If still not found, falls back to the first available media item.
+ *
+ * Special handling: If the resolved item's "src" is an empty string, returns undefined,
+ * since empty URIs are invalid in some platforms (e.g., React Native).
+ *
+ * @param {ZappEntry} entry - The entry object containing a media group.
+ * @param {string[] | unknown} arg - A single-element array containing the key to look up, or any unknown value.
+ * @returns {?string} The "src" URI from the matched media item, or undefined if not found or empty.
  */
 export function imageSrcFromMediaItem(
   entry: ZappEntry,
   arg: string[] | unknown
-) {
+): Option<string> {
   const args: unknown = R.unless(Array.isArray, Array)(arg || []);
   const imageKey: string = args?.[0] || "image_base"; // always a single key in this function
-  const mediaGroup = R.path<ZappMediaGroup[]>(["media_group"], entry);
 
-  if (!mediaGroup) {
+  const mediaItems = getMediaItems(entry);
+
+  if (!mediaItems) {
     return undefined;
   }
 
-  const hasTypeImageOrThumbnail = R.either(
-    R.propEq("type", "image"),
-    R.propEq("type", "thumbnail")
-  );
-
-  const pickMediaItemProp = R.prop<ZappMediaItem>("media_item");
+  // Try to find the item with the given key
+  let foundItem = mediaItems.find((item) => item.key === imageKey);
 
-  const mediaItems = R.compose(
-    R.flatten,
-    R.map(pickMediaItemProp),
-    R.filter(hasTypeImageOrThumbnail)
-  )(mediaGroup);
+  // If not found and key was not "image_base", try to find "image_base"
+  if (!foundItem && imageKey !== "image_base") {
+    foundItem = mediaItems.find((item) => item.key === "image_base");
+  }
 
-  if (!mediaItems) {
-    return undefined;
+  // If still not found, default to first item
+  if (!foundItem) {
+    foundItem = mediaItems[0];
   }
 
-  const src = R.compose(
-    R.prop("src"),
-    R.defaultTo(R.head(mediaItems)),
-    R.when(R.isNil, () => R.find(R.propEq("key", "image_base"), mediaItems)),
-    R.find(R.propEq("key", imageKey))
-  )(mediaItems);
-
-  // Special case for react native - uri cannot be an empty string (yellow warning).
-  // R.isEmpty is tailored specifically for checks like these,
-  // it returns false for undefined values.
-  return R.isEmpty(src) ? undefined : src;
+  const src = foundItem?.src;
+
+  // React Native quirk: empty string is invalid for URIs
+  return isEmpty(src) ? undefined : src;
 }
 
 /**
@@ -370,7 +399,7 @@ export const populateConfigurationValues =
       flattenAndPopulateFields(fields, configuration, skipDefaults)
   );
 
-export const getAccesabilityProps = (item: ZappEntry) => ({
+export const getAccessibilityProps = (item: ZappEntry) => ({
   accessible: item?.extensions?.accessibility,
   accessibilityLabel: item?.extensions?.accessibility?.label || item?.title,
   accessibilityHint: item?.extensions?.accessibility?.hint,