@applicaster/zapp-react-native-utils/appUtils/playerManager/OverlayObserver/utils.ts

Applicaster Zapp React Native utilities package

import { Image } from "react-native";
import {
  PipesClientResponseHelper,
  RequestBuilder,
} from "@applicaster/zapp-pipes-v2-client";
import { log_error, log_info } from "./OverlaysObserver";
import * as R from "ramda";
import { toNumber, toNumberWithDefault } from "../../../numberUtils";

export const parseTimeToSeconds = (timeStr: string): number => {
  const validationError = new Error("Invalid time format");

  if (!timeStr) {
    throw validationError;
  }

  const toTime = (value: number, max: number = 59): number => {
    // Validate the time value
    if (Number.isNaN(value) || value < 0 || value > max) {
      throw validationError;
    }

    return value;
  };

  // Split the time string by colon
  const parts = timeStr.split(":").map((part) => parseInt(part, 10));

  // Calculate the seconds based on the number of parts
  if (parts.length === 2) {
    // Format is MM:SS
    return toTime(parts[0]) * 60 + toTime(parts[1]);
  } else if (parts.length === 3) {
    // Format is HH:MM:SS
    return (
      toTime(parts[0], 23) * 3600 + toTime(parts[1]) * 60 + toTime(parts[2])
    );
  } else {
    throw validationError;
  }
};

export const retrieveFeedUrl = (entry: ZappEntry) =>
  entry?.extensions?.play_next_feed_url;

export const retrieveOverlayDuration = (plugin) =>
  toNumberWithDefault(plugin?.configuration?.overlay_duration, 15);

export const retrieveOverlayTriggerOffset = (item: ZappEntry) => {
  return item && item.extensions && item.extensions.overlay_timestamp
    ? toNumber(item.extensions.overlay_timestamp)
    : Number.MAX_SAFE_INTEGER;
};

const getImage = (playableItem: ZappEntry, key = "image_base") => {
  if (!playableItem || !playableItem.media_group) {
    return undefined;
  }

  const mediaGroups = Array.isArray(playableItem.media_group)
    ? playableItem.media_group
    : [playableItem.media_group];

  const mediaItems = mediaGroups.reduce((acc, group) => {
    return acc.concat(
      Array.isArray(group.media_item) ? group.media_item : [group.media_item]
    );
  }, []);

  const findMediaItemByKey = (items, key) =>
    items.find((item) => item.key === key) ||
    items.find((item) => item.key === "image_base") ||
    items[0];

  const mediaItem = findMediaItemByKey(mediaItems, key);

  return mediaItem?.src || null;
};

export const prefetchImage = (playableItem: ZappEntry, config: any = {}) => {
  if (!playableItem) {
    return;
  }

  const image_thumbnail_key = config?.image_thumbnail_key || "image_base";

  // Assuming getImage function is already rewritten as suggested in previous responses
  const previewUrl = getImage(playableItem, image_thumbnail_key);

  if (previewUrl) {
    Image.prefetch(previewUrl);
  }
};

export const loadFeedAndPrefetchThumbnailImage = async (
  playNextFeedUrl: string,
  entry: ZappEntry,
  playNextPlugin
) => {
  const requestBuilder = new RequestBuilder()
    .setEntryContext(entry)
    .setScreenContext({} as ZappRiver)
    .setUrl(playNextFeedUrl);

  const responseObject = await requestBuilder.call<ZappEntry>();
  const responseHelper = new PipesClientResponseHelper(responseObject);

  if (responseHelper.error) {
    log_error(
      `loadFeedAndPrefetchThumbnailImage: loading failed with error: ${responseHelper.error.message}. Play next observer, will not be executed`,
      {
        response: responseHelper.getLogsData(),
      }
    );

    throw responseHelper.error;
  } else {
    log_info(
      `loadFeedAndPrefetchThumbnailImage: Play next url was successfully loaded for url: ${playNextFeedUrl}. Prefetching image`,
      responseHelper.getLogsData()
    );

    const playNextEntry = responseHelper.responseData?.entry[0];

    if (!playNextEntry) {
      log_error(
        "loadFeedAndPrefetchThumbnailImage: Can not retrieve play next entry, feed was loaded but no entry was found",
        responseHelper.getLogsData()
      );

      throw new Error(
        "Can not retrieve play next entry, feed was loaded but no entry was found"
      );
    }

    prefetchImage(playNextEntry, playNextPlugin?.configuration);

    return playNextEntry;
  }
};

export const findPluginByIdentifier = (
  identifier: string,
  plugins: ZappPlugin[]
): ZappPlugin => {
  if (!identifier) {
    return undefined;
  }

  const plugin = R.compose(
    R.find(R.propEq("identifier", identifier)),
    R.values
  )(plugins);

  return plugin;
};