@applicaster/zapp-react-native-utils 14.0.0-alpha.4011674803 → 14.0.0-alpha.4552519200

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;
 }
 
 /**

package/manifestUtils/_internals/getDefaultConfiguration.js

@@ -0,0 +1,28 @@
+const R = require("ramda");
+const { defaultConfigurations } = require("../defaultManifestConfigurations");
+
+/**
+ * returns default configuration keys for provided plugin type
+ * @param {('general-content'|'player')} pluginType
+ * @param options manifest generator information
+ * @param {string} options.version manifest version
+ * @param {string} options.platform qb platform value
+ */
+function getDefaultConfiguration(pluginType, options) {
+  const defConfig = R.compose(
+    R.unless(R.isNil, (fn) => fn(options)),
+    R.propOr(null, pluginType)
+  )(defaultConfigurations);
+
+  if (!defConfig) {
+    const availableKeys = R.keys(defaultConfigurations);
+
+    const message = `Requested key "${pluginType}" doesn't exist in the default configuration\nAvailable keys: ${availableKeys}`;
+    // eslint-disable-next-line no-console
+    console.warn(message);
+  }
+
+  return defConfig;
+}
+
+module.exports = { getDefaultConfiguration };

package/manifestUtils/{_internals.js → _internals/index.js}

@@ -1,6 +1,7 @@
 const R = require("ramda");
 const camelize = require("camelize");
-const { defaultConfigurations } = require("./defaultManifestConfigurations");
+
+const { getDefaultConfiguration } = require("./getDefaultConfiguration");
 
 const toSnakeCase = R.compose(R.replace(/\s/g, "_"), R.toLower, R.trim);
 
@@ -173,30 +174,6 @@ function generateFieldsFromDefaultsWithoutPrefixedLabel(
   )(fields);
 }
 
-/**
- * returns default configuration keys for provided plugin type
- * @param {('general-content'|'player')} pluginType
- * @param options manifest generator information
- * @param {string} options.version manifest version
- * @param {string} options.platform qb platform value
- */
-function getDefaultConfiguration(pluginType, options) {
-  const defConfig = R.compose(
-    R.unless(R.isNil, (fn) => fn(options)),
-    R.propOr(null, pluginType)
-  )(defaultConfigurations);
-
-  if (!defConfig) {
-    const availableKeys = R.keys(defaultConfigurations);
-
-    const message = `Requested key "${pluginType}" doesn't exist in the default configuration\nAvailable keys: ${availableKeys}`;
-    // eslint-disable-next-line no-console
-    console.warn(message);
-  }
-
-  return defConfig;
-}
-
 module.exports = {
   toSnakeCase,
   toCamelCase,

package/manifestUtils/createConfig.js

@@ -1,5 +1,8 @@
 const R = require("ramda");
-const { getDefaultConfiguration } = require("./_internals");
+
+const {
+  getDefaultConfiguration,
+} = require("./_internals/getDefaultConfiguration");
 
 const indexByKey = R.indexBy((obj) => R.prop(obj.group ? "label" : "key", obj));
 const propIfExist = R.curry((prop) => R.when(R.prop(prop), R.prop(prop)));