@serifpersia/dango 3.6.7 → 3.6.9

package/server/dist/lib/anischedule.js

@@ -1,191 +0,0 @@
-import { parseJsonBody } from '../utils/http.utils.js';
-const SUB_SCHEDULE_URL = 'https://raw.githubusercontent.com/RockinChaos/AniSchedule/master/raw/sub-schedule.json';
-const SUB_FEED_URL = 'https://raw.githubusercontent.com/RockinChaos/AniSchedule/master/raw/sub-episode-feed.json';
-const HENTAI_FEED_URL = 'https://raw.githubusercontent.com/RockinChaos/AniSchedule/master/raw/hentai-episode-feed.json';
-const SCHEDULE_TTL_MS = 15 * 60 * 1000;
-const FEED_TTL_MS = 10 * 60 * 1000;
-const FETCH_TIMEOUT_MS = 10000;
-const scheduleCache = { data: null, expiry: 0 };
-const subFeedCache = { data: null, expiry: 0 };
-const hentaiFeedCache = { data: null, expiry: 0 };
-const inFlight = new Map();
-async function fetchJson(url) {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
-    try {
-        const response = await fetch(url, {
-            signal: controller.signal,
-            headers: { 'User-Agent': 'dango' },
-        });
-        if (!response.ok) {
-            throw new Error(`AniSchedule fetch failed with status ${response.status}`);
-        }
-        const json = await parseJsonBody(response);
-        if (Array.isArray(json) && json.length === 0) {
-            throw new Error('AniSchedule returned an empty payload');
-        }
-        return json;
-    }
-    finally {
-        clearTimeout(timer);
-    }
-}
-function fetchCached(key, url, cache, ttlMs) {
-    if (cache.data !== null && Date.now() < cache.expiry) {
-        return Promise.resolve(cache.data);
-    }
-    const existing = inFlight.get(key);
-    if (existing)
-        return existing;
-    const request = fetchJson(url)
-        .then((data) => {
-        cache.data = data;
-        cache.expiry = Date.now() + ttlMs;
-        return data;
-    })
-        .catch((err) => {
-        inFlight.delete(key);
-        throw err;
-    });
-    inFlight.set(key, request);
-    return request;
-}
-export function getAniScheduleShows() {
-    return fetchCached('anischedule:shows', SUB_SCHEDULE_URL, scheduleCache, SCHEDULE_TTL_MS);
-}
-export function getAniScheduleSubFeed() {
-    return fetchCached('anischedule:subfeed', SUB_FEED_URL, subFeedCache, FEED_TTL_MS);
-}
-export function getAniScheduleHentaiFeed() {
-    return fetchCached('anischedule:hentaifeed', HENTAI_FEED_URL, hentaiFeedCache, FEED_TTL_MS);
-}
-export function withScheduleFields(show, episode, airingAt) {
-    const now = Math.floor(Date.now() / 1000);
-    return {
-        ...show,
-        episodeNumber: episode,
-        aired: airingAt <= now,
-        nextAiring: { episode, timeUntilAiring: airingAt - now },
-        nextEpisodeAirDate: new Date(airingAt * 1000).toLocaleDateString('en-US', {
-            month: 'short',
-            day: 'numeric',
-            year: 'numeric',
-            timeZone: 'UTC',
-        }),
-        airTime: new Date(airingAt * 1000).toLocaleTimeString('en-US', {
-            hour: '2-digit',
-            minute: '2-digit',
-            timeZone: 'UTC',
-        }),
-    };
-}
-function fromAniScheduleShow(s) {
-    const title = s.title;
-    const name = title?.romaji || title?.english || title?.native || 'Unknown';
-    return {
-        _id: s.id.toString(),
-        id: s.id.toString(),
-        anilistId: s.id,
-        name,
-        englishName: title?.english,
-        nativeName: title?.native,
-        names: {
-            romaji: title?.romaji,
-            english: title?.english,
-            native: title?.native,
-        },
-        thumbnail: s.coverImage?.extraLarge || s.coverImage?.medium || '',
-        bannerImage: s.bannerImage || undefined,
-        genres: s.genres?.map((g) => ({ name: g })),
-        type: s.format,
-        year: s.seasonYear ?? undefined,
-        isAdult: s.isAdult,
-    };
-}
-export async function getScheduleFromAniSchedule(date, format, adult = false) {
-    const dayStart = Math.floor(date.getTime() / 1000);
-    const dayEnd = dayStart + 86400;
-    const now = Math.floor(Date.now() / 1000);
-    const formatFilter = format && format !== 'ALL' ? format : undefined;
-    const schedulePromise = getAniScheduleShows();
-    const subFeedPromise = getAniScheduleSubFeed();
-    const hentaiFeedPromise = adult ? getAniScheduleHentaiFeed() : Promise.resolve([]);
-    const [shows, subFeed, hentaiFeed] = await Promise.all([
-        schedulePromise,
-        subFeedPromise,
-        hentaiFeedPromise,
-    ]);
-    const showById = new Map();
-    for (const show of shows) {
-        showById.set(show.id, show);
-    }
-    const matchesAdult = (show) => (adult ? !!show.isAdult : !show.isAdult);
-    const bestByShow = new Map();
-    const missingMeta = new Map();
-    const consider = (id, episode, airingAt, entryFormat) => {
-        const show = showById.get(id);
-        if (show) {
-            if (formatFilter && show.format !== formatFilter)
-                return;
-            if (!matchesAdult(show))
-                return;
-            const key = show.idMal ?? show.id;
-            const current = bestByShow.get(key);
-            if (!current || airingAt > current.airingAt) {
-                bestByShow.set(key, {
-                    show: fromAniScheduleShow(show),
-                    episode,
-                    airingAt,
-                    aired: airingAt <= now,
-                });
-            }
-            return;
-        }
-        if (adult)
-            return;
-        if (formatFilter && entryFormat && entryFormat !== formatFilter)
-            return;
-        const existing = missingMeta.get(id);
-        if (!existing || airingAt > existing.airingAt) {
-            missingMeta.set(id, { id, episode, airingAt, format: entryFormat });
-        }
-    };
-    for (const show of shows) {
-        for (const node of show.airingSchedule.nodes) {
-            if (node.airingAt >= dayStart && node.airingAt < dayEnd) {
-                consider(show.id, node.episode, node.airingAt);
-            }
-        }
-    }
-    const feed = adult ? [...subFeed, ...hentaiFeed] : subFeed;
-    for (const entry of feed) {
-        const airedAt = Date.parse(entry.episode.airedAt) / 1000;
-        if (airedAt >= dayStart && airedAt < dayEnd) {
-            consider(entry.id, entry.episode.aired, airedAt, entry.format);
-        }
-    }
-    const entries = Array.from(bestByShow.entries())
-        .map(([, value]) => value)
-        .sort((a, b) => a.airingAt - b.airingAt);
-    return {
-        entries,
-        missingMeta: Array.from(missingMeta.values()),
-    };
-}
-export async function getAiredEpisodesFromAniScheduleFeed(ids, startEpoch, endEpoch) {
-    const idSet = new Set(ids);
-    const [subFeed, hentaiFeed] = await Promise.all([
-        getAniScheduleSubFeed(),
-        getAniScheduleHentaiFeed(),
-    ]);
-    const results = [];
-    for (const entry of [...subFeed, ...hentaiFeed]) {
-        if (!idSet.has(entry.id))
-            continue;
-        const airedAt = Date.parse(entry.episode.airedAt) / 1000;
-        if (airedAt >= startEpoch && airedAt <= endEpoch) {
-            results.push({ mediaId: entry.id, episode: entry.episode.aired, airingAt: airedAt });
-        }
-    }
-    return results;
-}

package/server/dist/lib/insights.js

@@ -1,185 +0,0 @@
-import logger from '../logger.js';
-import { InsightsRepository } from '../repositories/insights.repository.js';
-export async function getWatchInsights(db) {
-    const [core, activityGrid, hourlyDist, seasonality, allWatches, watchedShows, droppedWarning, velocities,] = (await Promise.all([
-        InsightsRepository.getCoreStats(db),
-        InsightsRepository.getActivityGrid(db),
-        InsightsRepository.getHourlyDist(db),
-        InsightsRepository.getSeasonality(db),
-        InsightsRepository.getAllWatches(db),
-        InsightsRepository.getWatchedShowsMeta(db),
-        InsightsRepository.getDroppedShows(db),
-        InsightsRepository.getCompletionVelocities(db),
-    ]));
-    const bingeFactor = activityGrid.length > 0 ? Math.max(...activityGrid.map((a) => a.count)) : 0;
-    const sessions = [];
-    if (allWatches.length > 0) {
-        let currentSessionSeconds = allWatches[0].effectiveSeconds ?? allWatches[0].currentTime;
-        for (let i = 1; i < allWatches.length; i++) {
-            const prev = new Date(allWatches[i - 1].watchedAt).getTime();
-            const curr = new Date(allWatches[i].watchedAt).getTime();
-            const gap = curr - prev;
-            if (Number.isFinite(gap) && gap > 0 && gap < 3600000) {
-                currentSessionSeconds += allWatches[i].effectiveSeconds ?? allWatches[i].currentTime;
-            }
-            else {
-                sessions.push(currentSessionSeconds);
-                currentSessionSeconds = allWatches[i].effectiveSeconds ?? allWatches[i].currentTime;
-            }
-        }
-        sessions.push(currentSessionSeconds);
-    }
-    const avgSessionMinutes = sessions.length > 0 ? Math.round(sessions.reduce((a, b) => a + b, 0) / sessions.length / 60) : 0;
-    const genreCounts = {};
-    let totalPopScore = 0;
-    let popCount = 0;
-    for (const show of watchedShows) {
-        let genres = [];
-        if (show.genres) {
-            try {
-                if (show.genres.startsWith('[')) {
-                    genres = JSON.parse(show.genres);
-                }
-                else {
-                    genres = show.genres.split(',').map((g) => g.trim());
-                }
-            }
-            catch (e) {
-                logger.warn({ err: e, showId: show.id }, 'Failed to parse genres for insights');
-            }
-        }
-        for (const g of genres) {
-            genreCounts[g] = (genreCounts[g] || 0) + 1;
-        }
-        if (show.popularityScore) {
-            let score = show.popularityScore;
-            if (score > 10)
-                score = score / 10;
-            totalPopScore += score;
-            popCount++;
-        }
-    }
-    const topGenre = Object.entries(genreCounts).sort((a, b) => b[1] - a[1])[0]?.[0];
-    const personaMap = {
-        Action: 'Shonen Warrior',
-        Romance: 'Hopeless Romantic',
-        Comedy: 'Chaos Enjoyer',
-        'Slice of Life': 'Vibe Seeker',
-        Horror: 'Fearless Watcher',
-        Fantasy: 'Isekai Traveller',
-        'Sci-Fi': 'Future Scientist',
-        Drama: 'Feels Collector',
-    };
-    const persona = personaMap[topGenre || ''] || 'Anime Enthusiast';
-    const avgCompletionDays = velocities.length > 0
-        ? Math.round(velocities.reduce((a, b) => a + b.daysToFinish, 0) / velocities.length)
-        : 0;
-    return {
-        totalHours: Math.round((core?.totalSeconds || 0) / 3600),
-        totalEpisodes: core?.totalEpisodes || 0,
-        totalAnime: core?.totalAnime || 0,
-        completedAnime: core?.completedCount || 0,
-        completionRate: core?.totalWatchlist > 0 ? Math.round((core.completedCount / core.totalWatchlist) * 100) : 0,
-        persona,
-        bingeFactor,
-        avgSessionMinutes,
-        avgCompletionDays,
-        popularityScore: popCount > 0 ? Math.round(totalPopScore / popCount) : 0,
-        genreSplit: Object.entries(genreCounts)
-            .map(([name, count]) => ({ name, count }))
-            .sort((a, b) => b.count - a.count)
-            .slice(0, 8) || [],
-        activityGrid: activityGrid || [],
-        hourlyDist: Array.from({ length: 24 }, (_, i) => {
-            const hour = i.toString().padStart(2, '0');
-            return { hour, count: hourlyDist?.find((d) => d.hour === hour)?.count || 0 };
-        }) || [],
-        seasonality: Array.from({ length: 12 }, (_, i) => {
-            const month = (i + 1).toString().padStart(2, '0');
-            return {
-                month,
-                seconds: seasonality?.find((s) => s.month === month)?.seconds || 0,
-            };
-        }) || [],
-        droppedShows: (droppedWarning || []).slice(0, 5),
-    };
-}
-export async function getGenreCards(db) {
-    const rows = await InsightsRepository.getWatchedEpisodesWithMeta(db);
-    const genreData = {};
-    for (const row of rows) {
-        let genres = [];
-        if (row.genres) {
-            try {
-                if (row.genres.startsWith('[')) {
-                    genres = JSON.parse(row.genres);
-                }
-                else {
-                    genres = row.genres.split(',').map((g) => g.trim());
-                }
-            }
-            catch (e) {
-                logger.warn({ err: e, showId: row.showId }, 'Failed to parse genres for genre cards');
-            }
-        }
-        const timeWatched = (row.effectiveSeconds ?? row.currentTime) || 0;
-        let score = row.popularityScore || 0;
-        if (score > 10)
-            score = score / 10;
-        for (const genre of genres) {
-            if (!genreData[genre]) {
-                genreData[genre] = { count: 0, totalTime: 0, scores: [], showWatches: {}, showMeta: {} };
-            }
-            genreData[genre].count++;
-            genreData[genre].totalTime += timeWatched;
-            if (score > 0)
-                genreData[genre].scores.push(score);
-            genreData[genre].showWatches[row.showId] = (genreData[genre].showWatches[row.showId] || 0) + 1;
-            if (row.name || row.thumbnail) {
-                genreData[genre].showMeta[row.showId] = {
-                    name: row.name,
-                    nativeName: row.nativeName,
-                    englishName: row.englishName,
-                    thumbnail: row.thumbnail,
-                };
-            }
-        }
-    }
-    const genreCards = Object.entries(genreData).map(([name, data]) => {
-        const topShows = Object.entries(data.showWatches)
-            .sort((a, b) => b[1] - a[1])
-            .slice(0, 4)
-            .map(([showId]) => ({
-            id: showId,
-            name: data.showMeta[showId]?.name || '',
-            nativeName: data.showMeta[showId]?.nativeName,
-            englishName: data.showMeta[showId]?.englishName,
-            thumbnail: data.showMeta[showId]?.thumbnail || '',
-        }));
-        return {
-            rank: 0,
-            name,
-            count: data.count,
-            meanScore: data.scores.length > 0 ? data.scores.reduce((a, b) => a + b, 0) / data.scores.length : 0,
-            timeWatched: formatTime(data.totalTime),
-            topShows,
-        };
-    });
-    genreCards.sort((a, b) => b.count - a.count);
-    genreCards.forEach((card, i) => {
-        card.rank = i + 1;
-    });
-    return genreCards;
-}
-function formatTime(seconds) {
-    const days = Math.floor(seconds / 86400);
-    const hours = Math.floor((seconds % 86400) / 3600);
-    const minutes = Math.floor((seconds % 3600) / 60);
-    if (days > 0) {
-        return `${days} days ${hours > 0 ? `${hours} hours` : ''}`;
-    }
-    if (hours > 0) {
-        return `${hours} hours${minutes > 0 ? ` ${minutes} mins` : ''}`;
-    }
-    return `${minutes} mins`;
-}

package/server/dist/lib/ipc.js

@@ -1,23 +0,0 @@
-import logger from '../logger.js';
-function sendToParent(message) {
-    try {
-        if (typeof process.send === 'function') {
-            process.send(message);
-        }
-    }
-    catch {
-        // ignore
-    }
-}
-export function notifySyncStart(message) {
-    sendToParent({ type: 'SYNC_START', message });
-    logger.info(`[SYNC_START] ${message}`);
-}
-export function notifySyncEnd() {
-    sendToParent({ type: 'SYNC_END' });
-    logger.info('[SYNC_END]');
-}
-export function notifyServerExit() {
-    sendToParent({ type: 'SERVER_EXIT' });
-    logger.info('[SERVER_EXIT]');
-}