@serifpersia/dango 3.4.4 → 3.4.6

package/server/dist/hono/watchlist.js

@@ -1,13 +1,11 @@
 import logger from '../logger.js';
 import { WatchlistRepository } from '../repositories/watchlist.repository.js';
-import { WatchedEpisodesRepository, } from '../repositories/watched-episodes.repository.js';
+import { WatchedEpisodesRepository } from '../repositories/watched-episodes.repository.js';
 import { ShowsMetaRepository } from '../repositories/shows-meta.repository.js';
 import { NotificationsRepository } from '../repositories/notifications.repository.js';
-import { SettingsRepository } from '../repositories/settings.repository.js';
 import { dbAll } from '../utils/db-utils.js';
 import { AppCache } from '../utils/cache.utils.js';
-import { searchAnilist, getAiredEpisodesForShows, getAnilistEpisodes, getShowMetaById, isAnilistRateLimited, batchGetShowStatuses, } from '../lib/anilist.js';
-import { offlineDb } from '../lib/offline-db.js';
+import { getAiredEpisodesForShows, isAnilistRateLimited, batchGetShowStatuses, } from '../lib/anilist.js';
 import { parseJsonBody } from '../utils/http.utils.js';
 import { pickBestMatch } from '../providers/title-matching.js';
 const BACKGROUND_DISCOVERY_INTERVAL_MS = 5 * 60 * 1000;
@@ -258,286 +256,6 @@ export function startWatchlistDiscovery(getDb) {
             runDiscovery(false);
     }, BACKGROUND_DISCOVERY_INTERVAL_MS);
 }
-async function showsMetaChanged(db, showId, candidate) {
-    const existing = (await ShowsMetaRepository.getById(db, showId));
-    if (!existing)
-        return true;
-    const differs = (incoming, stored) => {
-        if (incoming === undefined || incoming === null || incoming === '')
-            return false;
-        return String(incoming) !== String(stored ?? '');
-    };
-    return (differs(candidate.name, existing.name) ||
-        differs(candidate.thumbnail, existing.thumbnail) ||
-        differs(candidate.nativeName, existing.nativeName) ||
-        differs(candidate.englishName, existing.englishName) ||
-        differs(candidate.genres, existing.genres) ||
-        differs(candidate.popularityScore, existing.popularityScore) ||
-        differs(candidate.status, existing.status) ||
-        differs(candidate.episodeCount, existing.episodeCount) ||
-        differs(candidate.type, existing.type) ||
-        differs(candidate.anilistId, existing.anilistId) ||
-        differs(candidate.isAdult, existing.isAdult) ||
-        differs(candidate.episodeDuration, existing.episodeDuration));
-}
-function normalizeFilterValue(value) {
-    if (typeof value !== 'string')
-        return undefined;
-    const trimmed = value.trim();
-    return trimmed && trimmed !== 'ALL' ? trimmed : undefined;
-}
-function getWatchlistFilters(query) {
-    return {
-        query: normalizeFilterValue(query['query']),
-        type: normalizeFilterValue(query['type']),
-        season: normalizeFilterValue(query['season']),
-        year: normalizeFilterValue(query['year']),
-        genres: normalizeFilterValue(query['genres']),
-        excludeGenres: normalizeFilterValue(query['excludeGenres']),
-        sortBy: normalizeFilterValue(query['sortBy']),
-        titlePreference: ['name', 'nativeName', 'englishName'].includes(String(query['titlePreference']))
-            ? query['titlePreference']
-            : 'name',
-    };
-}
-function matchesLocalFilters(row, filters) {
-    if (filters.query) {
-        const queryWords = new Set(filters.query
-            .toLowerCase()
-            .split(/\s+/)
-            .filter((w) => w.length >= 2));
-        const rowTitle = (row.englishName || row.name || row.nativeName || '').toLowerCase();
-        const titleWords = rowTitle.split(/\s+/);
-        const overlap = titleWords.filter((w) => queryWords.has(w)).length;
-        if (overlap < queryWords.size)
-            return false;
-    }
-    return true;
-}
-function sortFilteredRows(rows, filters) {
-    const getSortTitle = (row) => {
-        const preferredTitle = filters.titlePreference ? row[filters.titlePreference] : undefined;
-        return preferredTitle || row.name || '';
-    };
-    if (filters.sortBy === 'name_asc') {
-        return [...rows].sort((a, b) => getSortTitle(a).localeCompare(getSortTitle(b)));
-    }
-    if (filters.sortBy === 'name_desc') {
-        return [...rows].sort((a, b) => getSortTitle(b).localeCompare(getSortTitle(a)));
-    }
-    return rows;
-}
-async function getAnilistSeasonYearMatches(season, year) {
-    const matched = new Map();
-    if (!year || year === 'ALL') {
-        return matched;
-    }
-    const seasonYear = parseInt(year);
-    if (Number.isNaN(seasonYear))
-        return matched;
-    const perPage = 50;
-    let page = 1;
-    while (true) {
-        const searchVars = {
-            seasonYear,
-            page,
-            perPage,
-        };
-        if (season && season !== 'ALL') {
-            searchVars.season = season.toUpperCase();
-        }
-        const results = await searchAnilist(searchVars);
-        for (const show of results) {
-            if (show.anilistId) {
-                matched.set(show.anilistId, { title: show.names || {} });
-            }
-        }
-        if (results.length < perPage)
-            break;
-        page++;
-        if (page > 10)
-            break;
-    }
-    return matched;
-}
-function rowMatchesAnilistSeasonYear(row, anilistMatches) {
-    if (anilistMatches.size === 0)
-        return true;
-    if (/^\d+$/.test(row.id) && anilistMatches.has(parseInt(row.id))) {
-        return true;
-    }
-    const rowTitle = (row.englishName || row.name || row.nativeName || '').toLowerCase();
-    if (!rowTitle)
-        return false;
-    const rowWords = new Set(rowTitle.split(/\s+/).filter((w) => w.length >= 2));
-    if (rowWords.size === 0)
-        return false;
-    for (const [, media] of anilistMatches) {
-        const titles = [media.title?.romaji, media.title?.english, media.title?.native].filter(Boolean);
-        for (const title of titles) {
-            const titleWords = new Set(title
-                .toLowerCase()
-                .split(/\s+/)
-                .filter((w) => w.length >= 2));
-            const overlap = [...rowWords].filter((w) => titleWords.has(w)).length;
-            const minLen = Math.min(rowWords.size, titleWords.size);
-            if (minLen >= 2 && overlap / minLen >= 0.7)
-                return true;
-        }
-    }
-    return false;
-}
-async function filterWatchlistRows(rows, filters, db) {
-    let filtered = rows.filter((row) => matchesLocalFilters(row, filters));
-    if (filters.type === 'ADULT' && db && filtered.length > 0) {
-        const ids = filtered.map((r) => r.id);
-        const placeholders = ids.map(() => '?').join(',');
-        const adultRows = await dbAll(db, `SELECT id FROM shows_meta WHERE id IN (${placeholders}) AND isAdult = 1`, ids);
-        const adultSet = new Set(adultRows.map((r) => r.id));
-        filtered = filtered.filter((row) => adultSet.has(row.id));
-    }
-    else if (filters.type && filters.type !== 'ALL' && filters.type !== 'ADULT') {
-        filtered = filtered.filter((row) => row.type === filters.type);
-    }
-    if ((filters.genres || filters.excludeGenres) && db) {
-        const ids = filtered.map((r) => r.id);
-        const placeholders = ids.map(() => '?').join(',');
-        const genreRows = await dbAll(db, `SELECT id, genres FROM shows_meta WHERE id IN (${placeholders})`, ids);
-        const idToGenres = new Map(genreRows.map((r) => [r.id, r.genres ? JSON.parse(r.genres) : []]));
-        const includeList = filters.genres
-            ?.split(',')
-            .map((g) => g.trim())
-            .filter(Boolean) || [];
-        const excludeList = filters.excludeGenres
-            ?.split(',')
-            .map((g) => g.trim())
-            .filter(Boolean) || [];
-        filtered = filtered.filter((row) => {
-            const rowGenres = idToGenres.get(row.id) || [];
-            if (includeList.length && !includeList.every((g) => rowGenres.includes(g)))
-                return false;
-            if (excludeList.length && excludeList.some((g) => rowGenres.includes(g)))
-                return false;
-            return true;
-        });
-    }
-    if (((filters.season && filters.season !== 'ALL') || (filters.year && filters.year !== 'ALL')) &&
-        filtered.length > 0) {
-        const anilistMatches = await getAnilistSeasonYearMatches(filters.season, filters.year);
-        if (anilistMatches.size > 0) {
-            filtered = filtered.filter((row) => rowMatchesAnilistSeasonYear(row, anilistMatches));
-        }
-    }
-    return sortFilteredRows(filtered, filters);
-}
-async function backfillMissingPosters(db, rows) {
-    const missing = rows.filter((r) => !r.thumbnail || r.thumbnail.trim() === '');
-    if (missing.length === 0)
-        return;
-    const slice = missing.slice(0, 10);
-    await Promise.allSettled(slice.map(async (row) => {
-        try {
-            const meta = await getShowMetaById(row.id);
-            const poster = meta?.thumbnail?.trim();
-            if (!poster)
-                return;
-            row.thumbnail = poster;
-            const dual = row;
-            if (dual._id !== undefined)
-                dual._id = row.id;
-            try {
-                await ShowsMetaRepository.upsert(db, {
-                    id: row.id,
-                    thumbnail: poster,
-                    popularityScore: meta?.score ?? (meta?.averageScore != null ? meta.averageScore / 10 : undefined),
-                });
-            }
-            catch {
-                // ignore
-            }
-            try {
-                await WatchlistRepository.updateThumbnail(db, row.id, poster);
-            }
-            catch {
-                // ignore
-            }
-        }
-        catch {
-            // ignore
-        }
-    }));
-    await sweepOfflinePosters(db);
-}
-async function sweepOfflinePosters(db) {
-    try {
-        db.run(`UPDATE shows_meta SET name = (SELECT w.name FROM watchlist w WHERE w.id = shows_meta.id)
-       WHERE (name IS NULL OR TRIM(name) = '')
-       AND EXISTS (SELECT 1 FROM watchlist w WHERE w.id = shows_meta.id AND w.name IS NOT NULL AND TRIM(w.name) != '')`);
-    }
-    catch {
-        // ignore
-    }
-    const [wlMissing, metaMissing] = await Promise.all([
-        WatchlistRepository.getMissingThumbnails(db),
-        ShowsMetaRepository.getShowIdsMissingMeta(db),
-    ]);
-    const ids = [...new Set([...wlMissing.map((r) => r.id), ...metaMissing.map((r) => r.id)])].slice(0, 500);
-    if (ids.length === 0)
-        return;
-    for (const id of ids) {
-        const poster = resolveOfflinePoster(id);
-        if (poster)
-            await applyPoster(db, id, poster);
-    }
-}
-function resolveOfflinePoster(id) {
-    if (/^\d+$/.test(id)) {
-        return offlineDb.getByAnilistId(Number(id))?.thumbnail?.trim() || null;
-    }
-    const mal = /^mal-(\d+)$/i.exec(id)?.[1];
-    if (mal)
-        return offlineDb.getByMalId(Number(mal))?.thumbnail?.trim() || null;
-    return null;
-}
-async function applyPoster(db, id, poster) {
-    try {
-        await ShowsMetaRepository.upsert(db, { id, thumbnail: poster });
-    }
-    catch {
-        // ignore
-    }
-    try {
-        await WatchlistRepository.updateThumbnail(db, id, poster);
-    }
-    catch {
-        // ignore
-    }
-}
-async function getContinueWatchingData(db, limit) {
-    const rows = await WatchedEpisodesRepository.getContinueWatching(db, limit);
-    const ignoreAdultRow = await SettingsRepository.getByKey(db, 'ignoreAdultContent');
-    const ignoreAdult = ignoreAdultRow ? ignoreAdultRow.value !== 'false' : true;
-    const watchlistOnlyRow = await SettingsRepository.getByKey(db, 'cwWatchlistOnly');
-    const watchlistOnly = watchlistOnlyRow
-        ? watchlistOnlyRow.value === 'true' || watchlistOnlyRow.value === '1'
-        : false;
-    const enrichedRows = rows
-        .filter((show) => {
-        if (ignoreAdult && show.isAdult)
-            return false;
-        if (watchlistOnly && show.watchlistStatus !== 'Watching')
-            return false;
-        return true;
-    })
-        .map((show) => ({
-        ...show,
-        episodeCount: show.episodeCount,
-        type: show.type || show.smType,
-        thumbnail: show.thumbnail ?? '',
-    }));
-    await backfillMissingPosters(db, enrichedRows);
-    return enrichedRows;
-}
 export async function getAdultNonWatchlistShowIds(db) {
     const rows = await dbAll(db, `SELECT DISTINCT we.showId as showId
      FROM watched_episodes we
@@ -546,13 +264,6 @@ export async function getAdultNonWatchlistShowIds(db) {
      WHERE w.id IS NULL`);
     return rows.map((r) => r.showId);
 }
-async function resolveAvailableEpisodes(db, showId) {
-    const episodeData = await getAnilistEpisodes(showId);
-    const episodes = Array.isArray(episodeData) && episodeData.length
-        ? [...episodeData].sort((a, b) => parseFloat(a) - parseFloat(b))
-        : [];
-    return episodes;
-}
 const dlsitePosterCache = new AppCache({ ttlSeconds: 3600, maxKeys: 2000 });
 const mangadexCoverCache = new AppCache({ ttlSeconds: 3600, maxKeys: 2000 });
 export async function getMangadexCover(title) {

package/server/dist/lib/anilist.js

@@ -21,9 +21,6 @@ export function anilistUnavailable() {
     }
     return false;
 }
-export function anilistIsDown() {
-    return anilistDownUntil > Date.now();
-}
 export function isAnilistRateLimited() {
     return anilistRateLimited && anilistCooldownUntil > Date.now();
 }

package/server/dist/lib/mal.js

@@ -153,44 +153,6 @@ function detailToSearchEntry(d) {
         score: d.score,
     };
 }
-export function toSearchEntry(e) {
-    if (!e || !e.malId || !e.title)
-        return null;
-    return {
-        id: -e.malId,
-        idMal: e.malId,
-        url: e.url ?? `https://myanimelist.net/anime/${e.malId}`,
-        title: e.title,
-        imageUrl: e.imageUrl ?? null,
-        synopsis: e.synopsis ?? null,
-        type: e.type ?? null,
-        episodes: e.episodes ?? null,
-        score: e.score ?? null,
-    };
-}
-export function toDetail(e, malId) {
-    if (!e || !e.title)
-        return null;
-    const genres = (Array.isArray(e.genres) ? e.genres : [])
-        .map((g) => (typeof g === 'string' ? g : g?.name))
-        .filter((g) => !!g);
-    return {
-        id: -malId,
-        idMal: malId,
-        url: e.url ?? `https://myanimelist.net/anime/${malId}`,
-        title: e.title,
-        titleEnglish: e.titleEnglish ?? null,
-        titleJapanese: e.titleJapanese ?? null,
-        imageUrl: e.imageUrl ?? e.images?.medium ?? null,
-        synopsis: e.synopsis ?? null,
-        type: e.type ?? null,
-        episodes: e.episodes ?? null,
-        status: e.status ?? null,
-        score: e.score ?? null,
-        rating: e.rating ?? null,
-        genres,
-    };
-}
 function mapMalStatus(status) {
     if (!status)
         return undefined;
@@ -603,9 +565,10 @@ export async function enrichCardTitles(store, items) {
 export async function malSearchMedia(store, options = {}, enrichTitles = true) {
     const { query, page = 1, format, status, season, seasonYear, genre, genre_in, genre_not_in, averageScore_greater, episodes_greater, isAdult, sort, } = options;
     const params = new URLSearchParams();
-    const hasQuery = !!query?.trim();
-    if (hasQuery)
-        params.set('q', query.trim());
+    const trimmedQuery = query?.trim();
+    const hasQuery = !!trimmedQuery;
+    if (trimmedQuery)
+        params.set('q', trimmedQuery);
     params.set('cat', 'anime');
     if (page > 1)
         params.set('show', String((page - 1) * 50));

package/server/dist/lib/offline-db.js

@@ -208,12 +208,6 @@ class OfflineDb {
     getByAnilistId(anilistId) {
         return this.anilistToEntry.get(anilistId) ?? null;
     }
-    getAnilistIdByMal(malId) {
-        return this.malToEntry.get(malId)?.anilistId ?? null;
-    }
-    getMalIdByAnilist(anilistId) {
-        return this.anilistToMal.get(anilistId) ?? null;
-    }
     async getOfflineDbInfo(db) {
         const get = async (key) => (await SettingsRepository.getByKey(db, key))?.value ?? null;
         const autoUpdate = await get('offlineDbAutoUpdateEnabled');

package/server/dist/lib/potoken.js

@@ -0,0 +1,135 @@
+import logger from '../logger.js';
+import { parseJsonBody } from '../utils/http.utils.js';
+import { getInnertube } from './ytmusic.js';
+const REQUEST_KEY = 'O43z0dpjhgX20SCx4KAo';
+const INTEGRITY_TTL_MS = 10 * 60 * 60 * 1000;
+const POT_CACHE_MS = 6 * 60 * 60 * 1000;
+let minter = null;
+let minterFetchedAt = 0;
+let bootstrapPromise = null;
+let bootstrapFailedAt = 0;
+const BOOTSTRAP_FAIL_COOLDOWN_MS = 60 * 1000;
+const potCache = new Map();
+// BotGuard needs browser globals to execute. They are installed once and kept
+// for the process lifetime: the minter's callbacks read them lazily at mint
+// time, long after bootstrap completes, so scoping them to bootstrap breaks
+// minting with `window is not defined`.
+async function setupDom() {
+    const g = globalThis;
+    if ('navigator' in g && g.yt)
+        return;
+    const { JSDOM, VirtualConsole } = await import('jsdom');
+    const virtualConsole = new VirtualConsole();
+    const dom = new JSDOM('<!DOCTYPE html><html lang="en"><head><title></title></head><body></body></html>', {
+        url: 'https://www.youtube.com',
+        referrer: 'https://www.youtube.com/',
+        virtualConsole,
+    });
+    Object.assign(g, {
+        window: dom.window,
+        document: dom.window.document,
+        location: dom.window.location,
+        origin: dom.window.origin,
+    });
+    if (!('navigator' in g)) {
+        Object.defineProperty(g, 'navigator', {
+            value: dom.window.navigator,
+            writable: true,
+            configurable: true,
+        });
+    }
+}
+async function buildMinter() {
+    const [{ BotGuardClient }, { WebPoMinter }, { buildURL, getHeaders, USER_AGENT }] = await Promise.all([
+        import('bgutils-js/botguard'),
+        import('bgutils-js/webpo'),
+        import('bgutils-js/utils'),
+    ]);
+    const yt = await getInnertube();
+    const pageResponse = await fetch('https://www.youtube.com', {
+        headers: {
+            accept: '*/*',
+            'accept-language': 'en-US,en;q=0.7',
+            'user-agent': USER_AGENT,
+        },
+    });
+    const pageHtml = await pageResponse.text();
+    const ytConfig = pageHtml.match(/ytcfg\.set\(({.+?})\);/s)?.[1];
+    if (ytConfig) {
+        const win = globalThis.window;
+        if (win)
+            win.yt = { config_: JSON.parse(ytConfig) };
+    }
+    const challenge = (await yt.getAttestationChallenge('ENGAGEMENT_TYPE_UNBOUND'));
+    const bgc = challenge.bg_challenge;
+    const interpreterUrl = bgc?.interpreter_url?.private_do_not_access_or_else_trusted_resource_url_wrapped_value;
+    if (!bgc?.program || !bgc.global_name || !interpreterUrl) {
+        throw new Error('No BotGuard challenge in response');
+    }
+    const bgScript = await (await fetch(`https:${interpreterUrl}`)).text();
+    if (!bgScript)
+        throw new Error('Could not load BotGuard VM');
+    new Function(bgScript)();
+    const botGuard = await BotGuardClient.create({
+        program: bgc.program,
+        globalName: bgc.global_name,
+        globalObject: globalThis,
+    });
+    const webPoSignalOutput = [];
+    const botguardResponse = await botGuard.snapshot({ webPoSignalOutput });
+    const itResponse = await fetch(buildURL('GenerateIT', true), {
+        method: 'POST',
+        headers: getHeaders(),
+        body: JSON.stringify([REQUEST_KEY, botguardResponse]),
+    });
+    const [integrityToken, estimatedTtlSecs, mintRefreshThreshold, websafeFallbackToken] = await parseJsonBody(itResponse);
+    if (!integrityToken)
+        throw new Error('Integrity token request failed');
+    logger.info('[pot] minter ready (integrity ttl %ss)', estimatedTtlSecs);
+    return WebPoMinter.create({
+        integrityToken,
+        estimatedTtlSecs,
+        mintRefreshThreshold,
+        websafeFallbackToken,
+    }, webPoSignalOutput);
+}
+async function getMinter() {
+    if (minter && Date.now() - minterFetchedAt < INTEGRITY_TTL_MS)
+        return minter;
+    if (Date.now() - bootstrapFailedAt < BOOTSTRAP_FAIL_COOLDOWN_MS) {
+        throw new Error('PoToken bootstrap cooling down');
+    }
+    if (!bootstrapPromise) {
+        bootstrapPromise = (async () => {
+            await setupDom();
+            const m = await buildMinter();
+            minter = m;
+            minterFetchedAt = Date.now();
+            return m;
+        })().catch((err) => {
+            bootstrapPromise = null;
+            bootstrapFailedAt = Date.now();
+            throw err;
+        });
+    }
+    return bootstrapPromise;
+}
+export async function mintPoToken(videoId) {
+    const cached = potCache.get(videoId);
+    if (cached && Date.now() - cached.fetchedAt < POT_CACHE_MS)
+        return cached.pot;
+    const m = await getMinter();
+    const pot = await m.mintAsWebsafeString(videoId);
+    potCache.set(videoId, { pot, fetchedAt: Date.now() });
+    return pot;
+}
+export function resetPoTokens(videoId) {
+    if (videoId)
+        potCache.delete(videoId);
+    else {
+        potCache.clear();
+        minter = null;
+        minterFetchedAt = 0;
+        bootstrapPromise = null;
+    }
+}

package/server/dist/lib/tracker/manga-sync.service.js

@@ -5,30 +5,11 @@ import { performMangaWriteTransactionAsync, performWriteTransactionAsync } from
 import logger from '../../logger.js';
 import { searchAnilistMangaByTitle, getMangaMetaById, getMangaMetaByMalId } from '../anilist.js';
 import { fetchMalMangaList, mapMalMangaStatusCode } from '../mal.js';
+import { readTrackerSyncState, resolveStatus, } from './sync-state.js';
 const TOKEN_KEY = 'tracker_anilist_token';
 const MANGA_SYNC_STATE_KEY = 'tracker_anilist_manga_sync_state';
 const MANGA_PROVIDER = 'anilist';
 const MAX_TITLE_LOOKUPS_PER_SYNC = 25;
-async function readMangaSyncState(db) {
-    const row = await SettingsRepository.getByKey(db, MANGA_SYNC_STATE_KEY);
-    if (!row?.value)
-        return {};
-    try {
-        return JSON.parse(row.value);
-    }
-    catch {
-        return {};
-    }
-}
-function resolveStatus(localStatus, remoteStatus, remoteUpdated, localLastSync) {
-    if (remoteUpdated > localLastSync && remoteStatus !== localStatus) {
-        return { status: remoteStatus, pull: true };
-    }
-    if (remoteStatus !== localStatus) {
-        return { status: localStatus, pull: false };
-    }
-    return { status: localStatus, pull: false };
-}
 function parseChapterProgress(value) {
     if (value == null)
         return 0;
@@ -122,7 +103,7 @@ export async function syncAniListManga(db, mangaDb, opts = {}) {
     const viewer = await tracker.getViewer();
     const remoteEntries = await tracker.fetchUserMangaList(viewer.id);
     const localItems = await MangaLibraryRepository.getAll(mangaDb);
-    const syncState = await readMangaSyncState(db);
+    const syncState = await readTrackerSyncState(db, MANGA_SYNC_STATE_KEY);
     const remoteByMediaId = new Map();
     for (const entry of remoteEntries)
         remoteByMediaId.set(entry.mediaId, entry);
@@ -618,7 +599,7 @@ export async function insertMangaImportEntries(db, mangaDb, items, eraseAnilistR
     if (items.length === 0)
         return 0;
     const now = Math.floor(Date.now() / 1000);
-    const syncState = await readMangaSyncState(db);
+    const syncState = await readTrackerSyncState(db, MANGA_SYNC_STATE_KEY);
     await performMangaWriteTransactionAsync(mangaDb, async (tx) => {
         if (eraseAnilistRows) {
             for (const row of await MangaLibraryRepository.getAll(tx)) {

package/server/dist/lib/tracker/sync-state.js

@@ -0,0 +1,21 @@
+import { SettingsRepository } from '../../repositories/settings.repository.js';
+export async function readTrackerSyncState(db, key) {
+    const row = await SettingsRepository.getByKey(db, key);
+    if (!row?.value)
+        return {};
+    try {
+        return JSON.parse(row.value);
+    }
+    catch {
+        return {};
+    }
+}
+export function resolveStatus(localStatus, remoteStatus, remoteUpdated, localLastSync) {
+    if (remoteUpdated > localLastSync && remoteStatus !== localStatus) {
+        return { status: remoteStatus, pull: true };
+    }
+    if (remoteStatus !== localStatus) {
+        return { status: localStatus, pull: false };
+    }
+    return { status: localStatus, pull: false };
+}

package/server/dist/lib/tracker/sync.service.js

@@ -11,33 +11,14 @@ import { fetchMalUserList } from '../mal.js';
 import { offlineDb } from '../offline-db.js';
 import { getShowMetaById, getShowMetaByMalId, isAnilistRateLimited, searchAnilistByTitle, } from '../anilist.js';
 import { kitsuSearchAnime } from '../kitsu.js';
+import { readTrackerSyncState, resolveStatus, } from './sync-state.js';
 const TOKEN_KEY = 'tracker_anilist_token';
 const USER_KEY = 'tracker_anilist_user';
 const SYNC_STATE_KEY = 'tracker_anilist_sync_state';
-async function readSyncState(db) {
-    const row = await SettingsRepository.getByKey(db, SYNC_STATE_KEY);
-    if (!row?.value)
-        return {};
-    try {
-        return JSON.parse(row.value);
-    }
-    catch {
-        return {};
-    }
-}
 async function getWatchedCount(db, showId) {
     const row = await dbGet(db, 'SELECT COUNT(DISTINCT episodeNumber) as total FROM watched_episodes WHERE showId = ?', [showId]);
     return row?.total ?? 0;
 }
-function resolveStatus(localStatus, remoteStatus, remoteUpdated, localLastSync) {
-    if (remoteUpdated > localLastSync && remoteStatus !== localStatus) {
-        return { status: remoteStatus, pull: true };
-    }
-    if (remoteStatus !== localStatus) {
-        return { status: localStatus, pull: false };
-    }
-    return { status: localStatus, pull: false };
-}
 export async function syncAniList(db) {
     const tokenRow = await SettingsRepository.getByKey(db, TOKEN_KEY);
     const token = tokenRow?.value;
@@ -47,7 +28,7 @@ export async function syncAniList(db) {
     const viewer = await tracker.getViewer();
     const remoteEntries = await tracker.fetchUserAnimeList(viewer.id);
     const localItems = await WatchlistRepository.getAll(db);
-    const syncState = await readSyncState(db);
+    const syncState = await readTrackerSyncState(db, SYNC_STATE_KEY);
     const remoteByMediaId = new Map();
     for (const entry of remoteEntries)
         remoteByMediaId.set(entry.mediaId, entry);
@@ -299,7 +280,7 @@ export async function importFromUsername(db, username, erase = false) {
     if (entries.length === 0)
         return 0;
     const now = Math.floor(Date.now() / 1000);
-    const syncState = await readSyncState(db);
+    const syncState = await readTrackerSyncState(db, SYNC_STATE_KEY);
     await performWriteTransactionAsync(db, async (tx) => {
         if (erase)
             await SettingsRepository.clearWatchlist(tx);