@serifpersia/dango 3.0.3

package/server/dist/lib/anischedule.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAniScheduleShows = getAniScheduleShows;
+exports.getAniScheduleSubFeed = getAniScheduleSubFeed;
+exports.getAniScheduleHentaiFeed = getAniScheduleHentaiFeed;
+exports.withScheduleFields = withScheduleFields;
+exports.getScheduleFromAniSchedule = getScheduleFromAniSchedule;
+exports.getAiredEpisodesFromAniScheduleFeed = getAiredEpisodesFromAniScheduleFeed;
+exports.isAniScheduleAvailable = isAniScheduleAvailable;
+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 response.json());
+        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;
+}
+function getAniScheduleShows() {
+    return fetchCached('anischedule:shows', SUB_SCHEDULE_URL, scheduleCache, SCHEDULE_TTL_MS);
+}
+function getAniScheduleSubFeed() {
+    return fetchCached('anischedule:subfeed', SUB_FEED_URL, subFeedCache, FEED_TTL_MS);
+}
+function getAniScheduleHentaiFeed() {
+    return fetchCached('anischedule:hentaifeed', HENTAI_FEED_URL, hentaiFeedCache, FEED_TTL_MS);
+}
+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,
+    };
+}
+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()),
+    };
+}
+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;
+}
+function isAniScheduleAvailable() {
+    return !!scheduleCache.data || !!subFeedCache.data;
+}

package/server/dist/lib/ipc.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notifySyncStart = notifySyncStart;
+exports.notifySyncEnd = notifySyncEnd;
+exports.notifyServerExit = notifyServerExit;
+const logger_1 = __importDefault(require("../logger"));
+function sendToParent(message) {
+    try {
+        if (typeof process.send === 'function') {
+            process.send(message);
+        }
+    }
+    catch {
+        // No IPC channel (dev under npm, or parent already gone).
+        // The stdout tag below remains the fallback signal.
+    }
+}
+function notifySyncStart(message) {
+    sendToParent({ type: 'SYNC_START', message });
+    logger_1.default.info(`[SYNC_START] ${message}`);
+}
+function notifySyncEnd() {
+    sendToParent({ type: 'SYNC_END' });
+    logger_1.default.info('[SYNC_END]');
+}
+function notifyServerExit() {
+    sendToParent({ type: 'SERVER_EXIT' });
+    logger_1.default.info('[SERVER_EXIT]');
+}