@serifpersia/dango 3.6.7 → 3.6.9

package/server/dist/lib/kitsu.js

@@ -1,517 +0,0 @@
-import logger from '../logger.js';
-import { parseJsonBody } from '../utils/http.utils.js';
-const KITSU_BASE = 'https://kitsu.app/api/edge';
-const KITSU_HEADERS = { Accept: 'application/vnd.api+json', 'User-Agent': 'dango' };
-const REQUEST_TIMEOUT_MS = 15000;
-const MAX_RETRIES = 3;
-async function kitsuFetch(path) {
-    let lastError = null;
-    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
-        try {
-            const controller = new AbortController();
-            const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
-            try {
-                const res = await fetch(`${KITSU_BASE}${path}`, {
-                    headers: KITSU_HEADERS,
-                    signal: controller.signal,
-                });
-                if (res.status === 429 || res.status >= 500) {
-                    lastError = `kitsu fetch failed with status ${res.status}`;
-                    await new Promise((r) => setTimeout(r, 1000 * attempt));
-                    continue;
-                }
-                if (!res.ok) {
-                    logger.warn({ status: res.status, path }, 'Kitsu request failed');
-                    return null;
-                }
-                return parseJsonBody(res);
-            }
-            finally {
-                clearTimeout(timer);
-            }
-        }
-        catch (err) {
-            lastError = err instanceof Error ? err.message : String(err);
-            if (attempt < MAX_RETRIES)
-                await new Promise((r) => setTimeout(r, 500 * attempt));
-        }
-    }
-    logger.warn({ lastError }, 'Kitsu request error');
-    return null;
-}
-function asArray(data) {
-    if (!data)
-        return [];
-    return Array.isArray(data) ? data : [data];
-}
-function includedMap(entry, included, type) {
-    if (!included || !entry.relationships)
-        return [];
-    const rel = entry.relationships[type];
-    if (!rel?.data)
-        return [];
-    const ids = new Set();
-    for (const item of Array.isArray(rel.data) ? rel.data : [rel.data]) {
-        ids.add(item.id);
-    }
-    return included.filter((i) => i.type === type && ids.has(i.id));
-}
-const STATUS_MAP = {
-    current: 'RELEASING',
-    finished: 'FINISHED',
-    upcoming: 'NOT_YET_RELEASED',
-    unreleased: 'NOT_YET_RELEASED',
-    tba: 'NOT_YET_RELEASED',
-};
-const SUBTYPE_MAP = {
-    tv: 'TV',
-    ova: 'OVA',
-    ona: 'ONA',
-    movie: 'MOVIE',
-    special: 'SPECIAL',
-    music: 'MUSIC',
-};
-const SEASON_BY_MONTH = [
-    'WINTER',
-    'WINTER',
-    'SPRING',
-    'SPRING',
-    'SPRING',
-    'SUMMER',
-    'SUMMER',
-    'SUMMER',
-    'FALL',
-    'FALL',
-    'FALL',
-    'WINTER',
-];
-function parseKitsuDate(s) {
-    if (typeof s !== 'string' || !s)
-        return undefined;
-    const m = s.match(/^(\d{4})-(\d{2})-(\d{2})/);
-    if (!m)
-        return undefined;
-    return { year: Number(m[1]), month: Number(m[2]), day: Number(m[3]) };
-}
-function statusToAnilist(status) {
-    if (!status)
-        return undefined;
-    return STATUS_MAP[status.toLowerCase()] ?? status.toUpperCase();
-}
-function formatToAnilist(subtype) {
-    if (!subtype)
-        return undefined;
-    return SUBTYPE_MAP[subtype.toLowerCase()] ?? subtype.toUpperCase();
-}
-function anilistSortToKitsu(sort) {
-    switch (sort) {
-        case 'SCORE_DESC':
-            return '-averageRating';
-        case 'FAVOURITES_DESC':
-            return '-favoritesCount';
-        case 'START_DATE_DESC':
-            return '-startDate';
-        case 'END_DATE_DESC':
-            return '-endDate';
-        case 'EPISODES_DESC':
-            return '-episodeCount';
-        case 'ID_DESC':
-            return '-id';
-        case 'UPDATED_AT_DESC':
-            return '-updatedAt';
-        default:
-            return '-userCount';
-    }
-}
-function statusToKitsuFilter(status) {
-    if (!status)
-        return undefined;
-    const s = status.toUpperCase();
-    if (s === 'RELEASING' || s === 'ONGOING')
-        return 'current';
-    if (s === 'FINISHED')
-        return 'finished';
-    if (s === 'NOT_YET_RELEASED' || s === 'UPCOMING' || s === 'HIATUS')
-        return 'upcoming';
-    return undefined;
-}
-function seasonToKitsu(season) {
-    if (!season)
-        return undefined;
-    return season.toLowerCase();
-}
-const CATEGORY_ALIASES = {
-    'Sci-Fi': 'Science Fiction',
-    'Sci Fi': 'Science Fiction',
-    Shounen: 'Shounen',
-};
-function normalizeCategory(cat) {
-    const c = cat.trim();
-    const alias = Object.entries(CATEGORY_ALIASES).find(([k]) => k.toLowerCase() === c.toLowerCase());
-    return alias ? alias[1] : c;
-}
-function mappingItem(entry, included) {
-    const rel = entry.relationships?.item?.data;
-    if (!rel)
-        return undefined;
-    if (Array.isArray(rel))
-        return undefined;
-    return included.find((i) => i.type === rel.type && i.id === rel.id);
-}
-export async function kitsuSearchAnime(options = {}) {
-    const { query, page = 1, perPage = 14, format, status, season, seasonYear, genre, genre_in, genre_not_in, averageScore_greater, episodes_greater, isAdult, sort, } = options;
-    const filters = [];
-    if (query)
-        filters.push(`filter[text]=${encodeURIComponent(query)}`);
-    if (format && format !== 'ALL' && format !== 'ADULT') {
-        filters.push(`filter[subtype]=${format.toLowerCase()}`);
-    }
-    const statusFilter = statusToKitsuFilter(status);
-    if (statusFilter)
-        filters.push(`filter[status]=${statusFilter}`);
-    const seasonFilter = seasonToKitsu(season);
-    if (seasonFilter && seasonFilter !== 'all')
-        filters.push(`filter[season]=${seasonFilter}`);
-    if (seasonYear)
-        filters.push(`filter[seasonYear]=${seasonYear}`);
-    const genreCombined = [
-        ...(Array.isArray(genre) ? genre : typeof genre === 'string' ? genre.split(',') : []),
-        ...(genre_in ?? []),
-    ]
-        .map((g) => g.trim())
-        .filter(Boolean)
-        .join(',');
-    if (genreCombined)
-        filters.push(`filter[categories]=${encodeURIComponent(genreCombined)}`);
-    const offset = (page - 1) * perPage;
-    const path = `/anime?${filters.join('&')}${filters.length ? '&' : ''}sort=${anilistSortToKitsu(sort)}&page[limit]=${perPage}&page[offset]=${offset}&include=mappings,categories`;
-    const json = await kitsuFetch(path);
-    if (!json)
-        return [];
-    const entries = asArray(json.data);
-    const included = json.included ?? [];
-    const results = [];
-    for (const entry of entries) {
-        const media = normalizeKitsuEntry(entry, included);
-        if (!media)
-            continue;
-        if (genre_not_in?.length) {
-            const hasExcluded = (media.genres ?? []).some((g) => genre_not_in.some((ng) => ng.toLowerCase() === g.toLowerCase()));
-            if (hasExcluded)
-                continue;
-        }
-        if (averageScore_greater != null && (media.averageScore ?? 0) < averageScore_greater)
-            continue;
-        if (episodes_greater != null && (media.episodes ?? 0) < episodes_greater)
-            continue;
-        if (isAdult === true && !media.isAdult)
-            continue;
-        if (isAdult === false && media.isAdult)
-            continue;
-        results.push(media);
-    }
-    return results;
-}
-export function dedupeKitsuMedia(list) {
-    const seen = new Set();
-    const out = [];
-    for (const m of list) {
-        const key = m.id > 0 ? m.id : (m.idMal ?? m.id);
-        if (seen.has(key))
-            continue;
-        seen.add(key);
-        out.push(m);
-    }
-    return out;
-}
-function normalizeKitsuEntry(entry, included, knownIds) {
-    const a = entry.attributes;
-    const mappings = includedMap(entry, included, 'mappings');
-    const anilistMapping = mappings.find((m) => m.attributes?.externalSite === 'anilist/anime');
-    const malMapping = mappings.find((m) => m.attributes?.externalSite === 'myanimelist/anime');
-    const anilistId = anilistMapping
-        ? Number(anilistMapping.attributes.externalId)
-        : (knownIds?.anilistId ?? null);
-    const malId = malMapping ? Number(malMapping.attributes.externalId) : (knownIds?.malId ?? null);
-    if (!anilistId && !malId)
-        return null;
-    const id = anilistId ?? -Math.abs(malId);
-    const title = {};
-    const titles = a.titles ?? {};
-    title.romaji =
-        titles.en_jp || titles.en || entry.attributes.canonicalTitle;
-    title.english = titles.en || titles.en_us || title.romaji;
-    title.native = titles.ja_jp || titles.ja || title.romaji;
-    const startDate = parseKitsuDate(a.startDate);
-    const endDate = parseKitsuDate(a.endDate);
-    const poster = a.posterImage ?? {};
-    const cover = a.coverImage ?? {};
-    const posterUrl = poster.large || poster.original || poster.medium || poster.small || poster.tiny || null;
-    const coverUrl = cover.large || cover.original;
-    const genres = includedMap(entry, included, 'categories')
-        .map((c) => c.attributes?.title)
-        .filter(Boolean)
-        .map((g) => normalizeCategory(g));
-    const nextAiringAt = a.nextRelease != null ? Math.floor(new Date(a.nextRelease).getTime() / 1000) : null;
-    return {
-        id,
-        idMal: malId,
-        title,
-        bannerImage: coverUrl || null,
-        coverImage: posterUrl
-            ? { extraLarge: posterUrl, large: posterUrl, medium: posterUrl }
-            : undefined,
-        description: a.synopsis || a.description || null,
-        genres: genres.length > 0 ? genres : undefined,
-        averageScore: a.averageRating != null ? Math.round(Number(a.averageRating)) : null,
-        format: formatToAnilist(a.subtype),
-        status: statusToAnilist(a.status),
-        episodes: a.episodeCount ?? null,
-        duration: a.episodeLength ?? null,
-        season: startDate?.month ? SEASON_BY_MONTH[startDate.month - 1] : undefined,
-        seasonYear: startDate?.year ?? undefined,
-        startDate,
-        endDate,
-        isAdult: !!a.nsfw,
-        synonyms: a.abbreviatedTitles ?? undefined,
-        popularity: a.userCount ?? undefined,
-        favourites: a.favoritesCount ?? undefined,
-        nextAiringEpisode: nextAiringAt != null
-            ? {
-                episode: 0,
-                timeUntilAiring: nextAiringAt - Math.floor(Date.now() / 1000),
-                airingAt: nextAiringAt,
-            }
-            : null,
-    };
-}
-async function kitsuIdByAnilistId(anilistId) {
-    const json = await kitsuFetch(`/mappings?filter[externalSite]=anilist%2Fanime&filter[externalId]=${anilistId}&include=item`);
-    const entries = asArray(json?.data);
-    if (entries.length === 0)
-        return null;
-    return mappingItem(entries[0], json?.included ?? [])?.id ?? null;
-}
-const KITSU_STATUS_MAP = {
-    current: 'RELEASING',
-    finished: 'FINISHED',
-    upcoming: 'NOT_YET_RELEASED',
-    unreleased: 'NOT_YET_RELEASED',
-    tba: 'NOT_YET_RELEASED',
-};
-export async function kitsuBatchGetStatuses(anilistIds) {
-    const result = new Map();
-    for (const id of anilistIds) {
-        try {
-            const json = await kitsuFetch(`/mappings?filter[externalSite]=anilist%2Fanime&filter[externalId]=${id}&include=item`);
-            const entries = asArray(json?.data);
-            if (entries.length === 0)
-                continue;
-            const included = json?.included ?? [];
-            const entry = entries[0];
-            const rel = entry.relationships?.item?.data;
-            if (!rel)
-                continue;
-            const relSingle = Array.isArray(rel) ? rel[0] : rel;
-            if (!relSingle)
-                continue;
-            const anime = included.find((i) => i.id === relSingle.id && i.type === 'anime');
-            if (!anime)
-                continue;
-            const raw = anime.attributes?.status?.toLowerCase();
-            const status = raw ? (KITSU_STATUS_MAP[raw] ?? raw.toUpperCase()) : undefined;
-            if (status)
-                result.set(id, status);
-        }
-        catch {
-            // ignore
-        }
-    }
-    return result;
-}
-async function kitsuDetail(kitsuId, knownIds) {
-    const [animeJson, studiosJson] = await Promise.all([
-        kitsuFetch(`/anime/${kitsuId}?include=categories,mappings`),
-        kitsuFetch(`/anime/${kitsuId}/anime-productions?include=producer&page[limit]=10`),
-    ]);
-    if (!animeJson)
-        return null;
-    const entry = asArray(animeJson.data)[0];
-    if (!entry)
-        return null;
-    const media = normalizeKitsuEntry(entry, animeJson.included ?? [], knownIds);
-    if (!media)
-        return null;
-    const producers = (studiosJson?.included ?? [])
-        .filter((i) => i.type === 'producers')
-        .map((i) => ({ id: 0, name: i.attributes?.name ?? '' }))
-        .filter((p) => p.name.length > 0);
-    if (producers.length > 0) {
-        media.studios = { nodes: producers };
-    }
-    return media;
-}
-export async function kitsuMetaByAnilistId(anilistId) {
-    const kitsuId = await kitsuIdByAnilistId(anilistId);
-    if (!kitsuId)
-        return null;
-    return kitsuDetail(kitsuId, { anilistId });
-}
-export async function kitsuMetaByMalId(malId) {
-    const json = await kitsuFetch(`/mappings?filter[externalSite]=myanimelist%2Fanime&filter[externalId]=${malId}&include=item`);
-    const entries = asArray(json?.data);
-    if (entries.length === 0)
-        return null;
-    const item = mappingItem(entries[0], json?.included ?? []);
-    if (!item)
-        return null;
-    return kitsuDetail(item.id, { malId });
-}
-export async function kitsuTitlesByMalIds(malIds) {
-    const result = new Map();
-    const unique = [...new Set(malIds.filter((n) => Number.isFinite(n) && n > 0))];
-    const CHUNK = 20;
-    const chunks = [];
-    for (let i = 0; i < unique.length; i += CHUNK)
-        chunks.push(unique.slice(i, i + CHUNK));
-    await Promise.all(chunks.map(async (ids) => {
-        try {
-            const json = await kitsuFetch(`/mappings?filter[externalSite]=myanimelist%2Fanime&filter[externalId]=${ids.join(',')}&include=item&page[limit]=${CHUNK}`);
-            if (!json)
-                return;
-            const animeById = new Map();
-            for (const inc of json.included ?? []) {
-                if (inc.type === 'anime')
-                    animeById.set(inc.id, inc);
-            }
-            for (const entry of asArray(json.data)) {
-                const rel = entry.relationships?.item?.data;
-                const single = Array.isArray(rel) ? rel[0] : rel;
-                if (!single)
-                    continue;
-                const titles = (animeById.get(single.id)?.attributes?.titles ?? {});
-                const english = titles.en || titles.en_us || undefined;
-                const native = titles.ja_jp || undefined;
-                if (!english && !native)
-                    continue;
-                const malId = Number(entry.attributes?.externalId);
-                if (!Number.isFinite(malId) || malId <= 0)
-                    continue;
-                result.set(malId, { english, native });
-            }
-        }
-        catch {
-            // ignore
-        }
-    }));
-    return result;
-}
-export async function kitsuEpisodes(anilistId, idMal) {
-    let kitsuId = null;
-    if (anilistId > 0)
-        kitsuId = await kitsuIdByAnilistId(anilistId);
-    if (!kitsuId && idMal != null) {
-        const json = await kitsuFetch(`/mappings?filter[externalSite]=myanimelist%2Fanime&filter[externalId]=${idMal}&include=item`);
-        const entries = asArray(json?.data);
-        if (entries.length > 0) {
-            kitsuId = mappingItem(entries[0], json?.included ?? [])?.id ?? null;
-        }
-    }
-    if (!kitsuId)
-        return [];
-    const all = [];
-    const LIMIT = 20;
-    let offset = 0;
-    while (offset < 1000) {
-        const json = await kitsuFetch(`/anime/${kitsuId}/episodes?page[limit]=${LIMIT}&page[offset]=${offset}&sort=number`);
-        if (!json)
-            break;
-        const entries = asArray(json.data);
-        if (entries.length === 0)
-            break;
-        for (const e of entries) {
-            const n = e.attributes?.number;
-            if (typeof n === 'number' && Number.isFinite(n) && n > 0)
-                all.push(n);
-        }
-        if (entries.length < LIMIT)
-            break;
-        offset += LIMIT;
-    }
-    if (all.length === 0)
-        return [];
-    const max = Math.max(...all);
-    return Array.from({ length: max }, (_, i) => (i + 1).toString());
-}
-export async function kitsuTrending(page = 1, perPage = 20, status) {
-    const statusFilter = statusToKitsuFilter(status);
-    const filters = statusFilter ? `filter[status]=${statusFilter}` : '';
-    const offset = (page - 1) * perPage;
-    const json = await kitsuFetch(`/anime?${filters}${filters ? '&' : ''}sort=-userCount&page[limit]=${perPage}&page[offset]=${offset}&include=mappings,categories`);
-    if (!json)
-        return [];
-    return dedupeKitsuMedia(asArray(json.data)
-        .map((e) => normalizeKitsuEntry(e, json.included ?? []))
-        .filter((m) => m !== null));
-}
-export async function kitsuSpotlight(page = 1, perPage = 20) {
-    const offset = (page - 1) * perPage;
-    const json = await kitsuFetch(`/anime?sort=-userCount&page[limit]=${perPage}&page[offset]=${offset}&include=mappings,categories`);
-    if (!json)
-        return [];
-    return dedupeKitsuMedia(asArray(json.data)
-        .map((e) => normalizeKitsuEntry(e, json.included ?? []))
-        .filter((m) => m !== null)
-        .filter((m) => !!m.bannerImage));
-}
-export async function kitsuLatestReleases(format = 'TV', page = 1, size = 12) {
-    const needed = page * size;
-    const formatFilter = format && format !== 'ALL' ? `filter[subtype]=${format.toLowerCase()}` : '';
-    const all = [];
-    let offset = 0;
-    const LIMIT = 20;
-    while (all.length < needed && offset < 500) {
-        const json = await kitsuFetch(`/anime?filter[status]=current${formatFilter ? `&${formatFilter}` : ''}&sort=-startDate&page[limit]=${LIMIT}&page[offset]=${offset}&include=mappings,categories`);
-        if (!json)
-            break;
-        const entries = asArray(json.data);
-        if (entries.length === 0)
-            break;
-        for (const e of entries) {
-            const m = normalizeKitsuEntry(e, json.included ?? []);
-            if (!m)
-                continue;
-            all.push(m);
-        }
-        offset += LIMIT;
-    }
-    all.sort((a, b) => {
-        const aNext = a.nextAiringEpisode?.airingAt ?? Number.MAX_SAFE_INTEGER;
-        const bNext = b.nextAiringEpisode?.airingAt ?? Number.MAX_SAFE_INTEGER;
-        if (aNext !== bNext)
-            return aNext - bNext;
-        const aStart = fallbackStartRank(a);
-        const bStart = fallbackStartRank(b);
-        if (aStart !== bStart)
-            return bStart - aStart;
-        return (b.popularity ?? 0) - (a.popularity ?? 0);
-    });
-    const start = (page - 1) * size;
-    return dedupeKitsuMedia(all.slice(start, start + size));
-}
-function fallbackStartRank(m) {
-    return ((m.startDate?.year ?? 0) * 10000 + (m.startDate?.month ?? 0) * 100 + (m.startDate?.day ?? 0));
-}
-export async function kitsuSeasonal(season, year, format, page = 1, size = 14) {
-    const filters = [`filter[season]=${seasonToKitsu(season)}`, `filter[seasonYear]=${year}`];
-    if (format && format !== 'ALL' && format !== 'ADULT') {
-        filters.push(`filter[subtype]=${format.toLowerCase()}`);
-    }
-    const offset = (page - 1) * size;
-    const json = await kitsuFetch(`/anime?${filters.join('&')}&sort=-userCount&page[limit]=${size}&page[offset]=${offset}&include=mappings,categories`);
-    if (!json)
-        return [];
-    return dedupeKitsuMedia(asArray(json.data)
-        .map((e) => normalizeKitsuEntry(e, json.included ?? []))
-        .filter((m) => m !== null));
-}