Pasted

/*
 
Script to get IMDb rating next to the release year under poster on cards in Jellyfin
Inspired by this post: https://www.reddit.com/r/jellyfin/comments/1qn68yy/jellyfin_ratings_setup_complete/
Disclaimer: Everything apart from code copied from the above script was written by my AI slaves.
 
1. Install Jellyfin JavaScript Injector
   https://github.com/n00bcodr/Jellyfin-JavaScript-Injector
 
2. Restart Jellyfin after installing the plugin.
 
3. Create an account on https://api.mdblist.com/ and generate an API key
   You will get 1K free requests per day. A $1.80 Patreon sub gives you 10K.
   If you show a lot of cards, 1K won't be enough, but you can set cache below.
   cURL command to check your rate limit info:
   $ curl "https://api.mdblist.com/user?apikey=YOUR_MDBLIST_API_KEY_HERE"
 
4. Go to: Dashboard → Plugins → JavaScript Injector
 
5. Paste the full JavaScript code into the large Custom JavaScript box and save.
 
*/
 
 
(function () {
'use strict';
 
const API_KEY = 'YOUR_MDBLIST_API_KEY_HERE';
const LOGO = 'https://cdn.jsdelivr.net/gh/Druidblack/jellyfin_ratings@main/logo/IMDb.png';
 
const CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
const REQUEST_DELAY_MS = 300;
 
const ratingCache = new Map();
const queue = [];
const queued = new WeakSet();
 
let queueRunning = false;
 
const visibleObserver = new IntersectionObserver(entries => {
    for (const entry of entries) {
        if (!entry.isIntersecting) continue;
 
        visibleObserver.unobserve(entry.target);
        enqueue(entry.target);
    }
}, {
    root: null,
    rootMargin: '600px 0px',
    threshold: 0.01
});
 
function scan(root = document) {
    root.querySelectorAll('.card[data-id]:not([data-imdb-done])').forEach(observeCard);
    root.querySelectorAll('.listItem[data-id]:not([data-imdb-done])').forEach(observeListItem);
}
 
function observeCard(card) {
    if (!['Movie', 'Series'].includes(card.dataset.type)) return;
 
    const target =
        card.querySelector('.cardText-secondary') ||
        card.querySelector('.cardText-first');
 
    if (!target) return;
 
    visibleObserver.observe(card);
}
 
function observeListItem(item) {
    if (!['Movie', 'Series'].includes(item.dataset.type)) return;
 
    const target = item.querySelector('.listItemBodyText');
 
    if (!target) return;
 
    visibleObserver.observe(item);
}
 
function enqueue(el) {
    if (el.dataset.imdbDone) return;
    if (queued.has(el)) return;
 
    queued.add(el);
    queue.push(el);
 
    runQueue();
}
 
function runQueue() {
    if (queueRunning) return;
 
    queueRunning = true;
    processNext();
}
 
function processNext() {
    const el = queue.shift();
 
    if (!el) {
        queueRunning = false;
        return;
    }
 
    processElement(el)
        .finally(() => {
            setTimeout(processNext, REQUEST_DELAY_MS);
        });
}
 
function processElement(el) {
    if (el.dataset.imdbDone) return Promise.resolve();
 
    const isList = el.classList.contains('listItem');
 
    let target;
 
    if (isList) {
        target = el.querySelector('.listItemBodyText');
    } else {
        target =
            el.querySelector('.cardText-secondary') ||
            el.querySelector('.cardText-first');
    }
 
    if (!target) return Promise.resolve();
 
    el.dataset.imdbDone = '1';
 
    return injectRating(el, target);
}
 
function injectRating(el, target) {
 
    const row = document.createElement('span');
 
    row.className = 'imdb-home-rating';
 
    row.style.cssText =
        'display:inline-flex;align-items:center;gap:0px;font-size:inherit;margin-left:8px;vertical-align:middle;color:inherit';
 
    target.appendChild(row);
 
    return ApiClient
        .getItem(ApiClient.getCurrentUserId(), el.dataset.id)
 
        .then(item => {
 
            if (!item || !item.ProviderIds) return null;
 
            const type =
                item.Type === 'Series'
                    ? 'show'
                    : 'movie';
 
            return getRating(type, item.ProviderIds);
        })
 
        .then(rating => {
 
            if (!rating) {
                row.remove();
                return;
            }
 
            row.innerHTML = '';
 
            const logo = document.createElement('span');
 
            logo.title = 'IMDb: ' + rating;
 
            logo.style.cssText =
                'display:inline-block;' +
                'height:1.15em;' +
                'width:2.6em;' +
                'background-color:currentColor;' +
                'mask:url("' + LOGO + '") center / contain no-repeat;' +
                '-webkit-mask:url("' + LOGO + '") center / contain no-repeat;' +
                'vertical-align:middle;' +
                'opacity:.55';
 
            const value = document.createElement('span');
 
            value.textContent = rating;
            value.style.color = 'inherit';
 
            row.append(
                logo,
                value
            );
        })
 
        .catch(() => {
            row.remove();
        });
}
 
function getRating(type, providerIds) {
 
    const tmdb = providerIds.Tmdb;
    const imdb = providerIds.Imdb;
    const tvdb = providerIds.Tvdb;
 
    const key =
        type +
        ':' +
        (tmdb || imdb || tvdb);
 
    if (ratingCache.has(key)) {
        return Promise.resolve(
            ratingCache.get(key)
        );
    }
 
    const cached =
        getCachedRating(key);
 
    if (cached !== undefined) {
 
        ratingCache.set(
            key,
            cached
        );
 
        return Promise.resolve(
            cached
        );
    }
 
    const urls = [];
 
    if (tmdb) {
        urls.push(
            `https://api.mdblist.com/tmdb/${type}/${tmdb}?apikey=${API_KEY}`
        );
    }
 
    if (imdb) {
        urls.push(
            `https://api.mdblist.com/imdb/${type}/${imdb}?apikey=${API_KEY}`
        );
    }
 
    if (tvdb) {
        urls.push(
            `https://api.mdblist.com/tvdb/${type}/${tvdb}?apikey=${API_KEY}`
        );
    }
 
    return tryUrls(
        urls,
        key
    );
}
 
function tryUrls(urls, key) {
 
    if (!urls.length) {
 
        ratingCache.set(
            key,
            null
        );
 
        setCachedRating(
            key,
            null
        );
 
        return Promise.resolve(
            null
        );
    }
 
    const url =
        urls.shift();
 
    return fetch(url)
 
        .then(r =>
            r.ok
                ? r.json()
                : null
        )
 
        .then(j => {
 
            const imdb =
                j &&
                Array.isArray(j.ratings)
 
                    ? j.ratings.find(
                        x =>
                            String(
                                x.source || ''
                            ).toLowerCase()
                            === 'imdb'
                    )
 
                    : null;
 
            const value =
                imdb &&
                imdb.value != null
 
                    ? Number(
                        imdb.value
                    ).toFixed(1)
 
                    : null;
 
            if (value) {
 
                ratingCache.set(
                    key,
                    value
                );
 
                setCachedRating(
                    key,
                    value
                );
 
                return value;
            }
 
            return tryUrls(
                urls,
                key
            );
        })
 
        .catch(() =>
            tryUrls(
                urls,
                key
            )
        );
}
 
function getCachedRating(key) {
 
    const raw =
        localStorage.getItem(
            'imdb-rating:' + key
        );
 
    if (!raw)
        return undefined;
 
    try {
 
        const cached =
            JSON.parse(raw);
 
        if (
            !cached ||
            typeof cached !== 'object'
        )
            return undefined;
 
        if (
            Date.now()
            - cached.time
            > CACHE_TTL_MS
        )
            return undefined;
 
        return cached.value;
 
    } catch {
 
        return undefined;
    }
}
 
function setCachedRating(
    key,
    value
) {
    try {
 
        localStorage.setItem(
            'imdb-rating:' + key,
 
            JSON.stringify({
                time:
                    Date.now(),
 
                value
            })
        );
 
    } catch {}
}
 
new MutationObserver(
    mutations => {
 
        for (
            const mutation
            of mutations
        ) {
 
            for (
                const node
                of mutation.addedNodes
            ) {
 
                if (
                    node.nodeType !== 1
                )
                    continue;
 
                scan(node);
            }
        }
    }
)
 
.observe(
    document.body,
    {
        childList: true,
        subtree: true
    }
);
 
setTimeout(
    scan,
    1000
);
 
setTimeout(
    scan,
    3000
);
 
setTimeout(
    scan,
    6000
);
 
window.addEventListener(
    'hashchange',
    () =>
        setTimeout(
            scan,
            1000
        )
);
 
window.addEventListener(
    'popstate',
    () =>
        setTimeout(
            scan,
            1000
        )
);
 
document.addEventListener(
    'viewshow',
    () =>
        setTimeout(
            scan,
            1000
        )
);
 
setInterval(
    scan,
    3000
);
 
})();