@serifpersia/dango 3.0.3

package/server/dist/lib/kitsu.js

@@ -0,0 +1,552 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kitsuSearchAnime = kitsuSearchAnime;
+exports.dedupeKitsuMedia = dedupeKitsuMedia;
+exports.kitsuBatchGetStatuses = kitsuBatchGetStatuses;
+exports.kitsuMetaByAnilistId = kitsuMetaByAnilistId;
+exports.kitsuMetaByMalId = kitsuMetaByMalId;
+exports.kitsuTitlesByMalIds = kitsuTitlesByMalIds;
+exports.kitsuEpisodes = kitsuEpisodes;
+exports.kitsuTrending = kitsuTrending;
+exports.kitsuSpotlight = kitsuSpotlight;
+exports.kitsuLatestReleases = kitsuLatestReleases;
+exports.kitsuSeasonal = kitsuSeasonal;
+const logger_1 = __importDefault(require("../logger"));
+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_1.default.warn({ status: res.status, path }, 'Kitsu request failed');
+                    return null;
+                }
+                return (await res.json());
+            }
+            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_1.default.warn({ lastError }, 'Kitsu request error');
+    return null;
+}
+function asArray(data) {
+    if (!data)
+        return [];
+    return Array.isArray(data) ? data : [data];
+}
+/** Builds a map of kitsu relationship id -> included resource for a given type. */
+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));
+}
+/** Kitsu status/subtype/season values are lowercase; map to AniList-style values. */
+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';
+    }
+}
+/** Translates an AniList-style status filter to a Kitsu filter value. */
+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();
+}
+/** Kitsu genre-ish taxonomy: `categories`. */
+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;
+}
+/**
+ * Resolves the included anime resource linked by a mapping entry's `item` relationship.
+ */
+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);
+}
+/**
+ * Fetches a list of anime from Kitsu and normalizes entries to AnilistMedia.
+ * `include=mappings,categories` gives AniList/MAL ids + genres in one request.
+ */
+async function kitsuSearchAnime(options = {}) {
+    const { query, page = 1, perPage = 14, format, status, season, seasonYear, genre, 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}`);
+    if (genre)
+        filters.push(`filter[categories]=${encodeURIComponent(genre)}`);
+    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;
+}
+/** Deduplicates by the resolved AniList/MAL id (keeps the first occurrence). */
+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;
+}
+/** Converts a Kitsu entry + included resources into AnilistMedia (id = AniList or MAL id). */
+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,
+    };
+}
+/**
+ * Finds the Kitsu entry id for a given AniList id via the mappings endpoint.
+ */
+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',
+};
+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 {
+            // skip failed lookups
+        }
+    }
+    return result;
+}
+/** Fetches full detail (genres + studios) for a Kitsu anime id. */
+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;
+}
+async function kitsuMetaByAnilistId(anilistId) {
+    const kitsuId = await kitsuIdByAnilistId(anilistId);
+    if (!kitsuId)
+        return null;
+    return kitsuDetail(kitsuId, { anilistId });
+}
+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 });
+}
+/** Batch-resolves English/Japanese titles for MAL ids via the mappings endpoint. */
+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;
+}
+/** Episode numbers for a show, via the episodes relationship. */
+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());
+}
+/** Trending proxy: currently-airing shows sorted by popularity (user count). */
+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));
+}
+/** Spotlight: top popular shows with native Kitsu banners (3360x800). */
+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));
+}
+/**
+ * Latest releases: currently-airing shows. Kitsu has no reliable episode airdates,
+ * so we sort current shows by start date (newest first) and bump shows with a known
+ * next episode date to the front (soonest first).
+ */
+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));
+}
+/** Seasonal list for a given season/year, matching AniList's POPULARITY_DESC order. */
+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));
+}