rivalsjs/dist/v1/index.mjs

<h1 align="center"> Rivals JS </h1>

import { c as convertToAssetUrl, b as buildQueryString } from '../utils-Dd1WfmFA.mjs';
import { fromPromise } from 'neverthrow';
import '../constants-DMfBNXMm.mjs';

function transformAllAchievementsResponse(data) {
  const transformedData = {
    ...data,
    achievements: data.achievements.map((achievement) => ({
      ...achievement,
      icon: convertToAssetUrl(achievement.icon)
    }))
  };
  return transformedData;
}
function transformAchievementResponse(data) {
  return {
    ...data,
    icon: convertToAssetUrl(data.icon)
  };
}

function transformBattlepassResponse(data) {
  const transformedData = {
    ...data
  };
  if (transformedData.items.length > 0) {
    transformedData.items = transformedData.items.map((item) => ({
      ...item,
      image: convertToAssetUrl(item.image)
    }));
  }
  return transformedData;
}

function transformAllHeroesResponse(data) {
  return data.map((hero) => transformHeroResponse(hero));
}
function transformHeroResponse(data) {
  return {
    ...data,
    imageUrl: convertToAssetUrl(data.imageUrl),
    transformations: data.transformations.map((transformation) => ({
      ...transformation,
      icon: convertToAssetUrl(transformation.icon)
    })),
    costumes: data.costumes.map((costume) => ({
      ...costume,
      icon: convertToAssetUrl(costume.icon)
    })),
    abilities: data.abilities.map((ability) => ({
      ...ability,
      icon: convertToAssetUrl(ability.icon)
    }))
  };
}
function transformHeroLeaderboardResponse(data) {
  return data.players.map((entry) => transformHeroLeaderboardEntry(entry));
}
function transformHeroLeaderboardEntry(data) {
  return {
    ...data,
    info: {
      ...data.info,
      icon: {
        ...data.info.icon,
        playerIcon: convertToAssetUrl(data.info.icon.playerIcon)
      }
    }
  };
}

function transformAllMapsResponse(data) {
  const transformedData = {
    ...data,
    maps: data.maps.map((map) => ({
      ...map,
      images: map.images.map((image) => convertToAssetUrl(image)),
      subMap: map.subMap ? {
        ...map.subMap,
        thumbnail: map.subMap.thumbnail ? convertToAssetUrl(map.subMap.thumbnail) : null
      } : null
    }))
  };
  return transformedData;
}

function transformMatchResponse(data) {
  const transformedData = {
    ...data.matchDetails,
    matchPlayers: data.matchDetails.matchPlayers.map((player) => ({
      ...player,
      curHeroIcon: convertToAssetUrl(player.curHeroIcon),
      playerHeroes: player.playerHeroes.map((hero) => ({
        ...hero,
        heroIcon: convertToAssetUrl(hero.heroIcon)
      })),
      badges: player.badges ? player.badges.map((badge) => ({
        ...badge,
        image: badge.image ? convertToAssetUrl(badge.image) : null
      })) : null
    }))
  };
  return transformedData;
}

function transformFindPlayerResponse(data) {
  return data;
}
function transformUpdatePlayerResponse(data) {
  if ("error" in data) {
    return {
      success: false,
      message: data.message,
      status: data.status ?? 500
    };
  }
  return {
    success: data.success,
    message: data.message,
    status: 200
  };
}
function transformGetPlayerResponse(data) {
  const transformedData = {
    ...data,
    player: {
      ...data.player,
      icon: {
        ...data.player.icon,
        playerIcon: convertToAssetUrl(data.player.icon.playerIcon)
      },
      rank: {
        ...data.player.rank,
        image: convertToAssetUrl(data.player.rank.image)
      }
    },
    matchHistory: data.matchHistory.map((match) => ({
      ...match,
      mapThumbnail: convertToAssetUrl(match.mapThumbnail),
      playerPerformance: {
        ...match.playerPerformance,
        heroType: convertToAssetUrl(match.playerPerformance.heroType)
      }
    })),
    heroMatchups: data.heroMatchups.map((matchup) => ({
      ...matchup,
      heroThumbnail: convertToAssetUrl(matchup.heroThumbnail)
    })),
    teamMates: data.teamMates.map((teammate) => ({
      ...teammate
    })),
    heroesRanked: data.heroesRanked.map((hero) => ({
      ...hero,
      heroThumbnail: convertToAssetUrl(hero.heroThumbnail)
    })),
    heroesUnranked: data.heroesUnranked.map((hero) => ({
      ...hero,
      heroThumbnail: convertToAssetUrl(hero.heroThumbnail)
    })),
    maps: data.maps.map((map) => ({
      ...map,
      mapThumbnail: convertToAssetUrl(map.mapThumbnail)
    }))
  };
  return transformedData;
}
function transformPlayerMatchHistoryResponse(data) {
  return data.matchHistory.map((entry) => ({
    ...entry,
    mapThumbnail: convertToAssetUrl(entry.mapThumbnail),
    matchPlayer: {
      ...entry.matchPlayer,
      playerHero: {
        ...entry.matchPlayer.playerHero,
        heroType: convertToAssetUrl(entry.matchPlayer.playerHero.heroType)
      }
    }
  }));
}

function transformHealthCheckResponse(data) {
  return data;
}

async function getAllAchievements(client, page = 1, perPage = 10) {
  return fromPromise(
    client.get(routes.allAchievements(page, perPage)),
    (error) => String(error)
  ).map((response) => transformAllAchievementsResponse(response.data));
}
async function getAchievement(client, name) {
  return fromPromise(
    client.get(routes.achievement(name)),
    (error) => String(error)
  ).map((response) => transformAchievementResponse(response.data));
}

async function getBattlepass(client, season) {
  return fromPromise(
    client.get(routes.battlepass(season)),
    (error) => String(error)
  ).map((response) => transformBattlepassResponse(response.data));
}

async function getAllHeroes(client) {
  return fromPromise(
    client.get(routes.allHeroes()),
    (error) => String(error)
  ).map((response) => transformAllHeroesResponse(response.data));
}
async function getHero(client, name) {
  return fromPromise(
    client.get(routes.hero(name)),
    (error) => String(error)
  ).map((response) => transformHeroResponse(response.data));
}
async function getHeroLeaderboard(client, name) {
  return fromPromise(
    client.get(routes.heroLeaderboard(name)),
    (error) => String(error)
  ).map((response) => transformHeroLeaderboardResponse(response.data));
}

async function getAllMaps(client, page = 1, perPage = 10) {
  return fromPromise(
    client.get(routes.allMaps(page, perPage)),
    (error) => String(error)
  ).map((response) => transformAllMapsResponse(response.data));
}

async function getMatch(client, matchId) {
  return fromPromise(
    client.get(routes.singleMatch(matchId)),
    (error) => String(error)
  ).map((response) => transformMatchResponse(response.data));
}

async function searchPlayer(client, username) {
  return fromPromise(
    client.get(routes.searchPlayer(username)),
    (error) => String(error)
  ).map((response) => transformFindPlayerResponse(response.data));
}
async function getPlayer(client, player, season) {
  return fromPromise(
    client.get(routes.player(player, season)),
    (error) => String(error)
  ).map((response) => transformGetPlayerResponse(response.data));
}
async function updatePlayer(client, player) {
  return fromPromise(
    client.get(routes.updatePlayer(player)),
    (error) => String(error)
  ).map((response) => transformUpdatePlayerResponse(response.data));
}
async function getPlayerMatchHistory(client, uid, season, skip, gameMode, timestamp) {
  return fromPromise(
    client.get(
      routes.getPlayerMatchHistory(uid, season, skip, gameMode, timestamp)
    ),
    (error) => String(error)
  ).map((response) => transformPlayerMatchHistoryResponse(response.data));
}

async function getHealthCheck(client) {
  return fromPromise(
    client.get(routes.healthCheck()),
    (error) => String(error)
  ).map((response) => transformHealthCheckResponse(response.data));
}

const routes = {
  healthCheck() {
    return "/v1";
  },
  battlepass(season) {
    const url = "/v1/battlepass";
    return buildQueryString(url, {
      season: season ?? void 0
    });
  },
  allAchievements(page = 1, perPage = 10) {
    const url = "/v1/achievements";
    return buildQueryString(url, {
      page: page > 0 ? page : 1,
      perPage: perPage > 0 ? perPage : 10
    });
  },
  achievement(name) {
    if (!name) {
      throw new Error("Achievement name is required");
    }
    return `/v1/achievement/${encodeURIComponent(name)}`;
  },
  allMaps(page = 1, perPage = 10) {
    const url = "/v1/maps";
    return buildQueryString(url, {
      page: page > 0 ? page : 1,
      limit: perPage > 0 ? perPage : 10
    });
  },
  searchPlayer(username) {
    if (!username) {
      throw new Error("Username is required");
    }
    return `/v1/find-player/${encodeURIComponent(username)}`;
  },
  player(player, season) {
    if (!player) {
      throw new Error("Player identifier is required");
    }
    return buildQueryString(`/v1/player/${encodeURIComponent(player)}`, {
      season: season ?? void 0
    });
  },
  updatePlayer(player) {
    if (!player) {
      throw new Error("Player identifier is required");
    }
    return `/v1/player/${encodeURIComponent(player)}/update`;
  },
  getPlayerMatchHistory(uid, season, skip, gameMode, timestamp) {
    if (!uid) {
      throw new Error("Player UID is required");
    }
    const url = `/v1/player/${encodeURIComponent(uid)}/match-history`;
    return buildQueryString(url, {
      season: season ?? void 0,
      skip: skip ?? void 0,
      game_mode: gameMode ?? void 0,
      timestamp: timestamp ?? void 0
    });
  },
  allHeroes() {
    return "/v1/heroes";
  },
  hero(name) {
    return `/v1/heroes/hero/${encodeURIComponent(name)}`;
  },
  heroLeaderboard(name) {
    return `/v1/heroes/leaderboard/${encodeURIComponent(name)}`;
  },
  singleMatch(matchId) {
    return `/v1/match/${encodeURIComponent(matchId)}`;
  }
};

export { getAchievement, getAllAchievements, getAllHeroes, getAllMaps, getBattlepass, getHealthCheck, getHero, getHeroLeaderboard, getMatch, getPlayer, getPlayerMatchHistory, routes, searchPlayer, updatePlayer };
//# sourceMappingURL=index.mjs.map