☰

Greasy Fork is available in English.

IMDb with additional ratings

Adds additional ratings (TMDB, Douban, Metacritic, MyAnimeList). These can be deactivated individually in the configuration menu. And movie info can be copied by clicking unlinked elements below the title.

Από την 14/09/2024. Δείτε την τελευταία έκδοση.

  1. // ==UserScript==
  2. // @name           IMDb with additional ratings
  3. // @description    Adds additional ratings (TMDB, Douban, Metacritic, MyAnimeList). These can be deactivated individually in the configuration menu. And movie info can be copied by clicking unlinked elements below the title.
  4. // @version        20240914
  5. // @author         mykarean
  6. // @icon           https://icons.duckduckgo.com/ip2/imdb.com.ico
  7. // @match          https://*.imdb.com/title/*
  8. // @grant          GM_getValue
  9. // @grant          GM_setValue
  10. // @grant          GM_addStyle
  11. // @grant          GM_xmlhttpRequest
  12. // @grant          GM_registerMenuCommand
  13. // @run-at         document-start
  14. // @compatible     chrome
  15. // @license        GPL3
  16. // @namespace https://greasyfork.org/users/1367334
  17. // ==/UserScript==
  18.  
  19. "use strict";
  20.  
  21. // -----------------------------------------------------------------------------------------------------
  22. // Config/Requirements
  23. // -----------------------------------------------------------------------------------------------------
  24.  
  25. GM_registerMenuCommand("Configuration", openConfiguration, "c");
  26.  
  27. const ratingSources = ["TMDB", "Douban", "Metacritic", "MyAnimeList"];
  28. const imdbId = window.location.pathname.match(/title\/(tt\d+)\//)[1];
  29. const USER_AGENT = "Mozilla/5.0 (x64; rv) Gecko Firefox";
  30. const undefinedValue = "X";
  31. let local;
  32.  
  33. function getTitleElement() {
  34.     return document.querySelector('[data-testid="hero__pageTitle"]');
  35. }
  36. function getMainTitle() {
  37.     return getTitleElement()?.textContent;
  38. }
  39. function getOriginalTitle() {
  40.     let originalTitle = document.querySelector('[data-testid="hero__pageTitle"] ~ div')?.textContent?.match(/^.*:\ (.*)/)?.[1];
  41.     // Unicode normalisation and removal of diacritical characters to improve search on other pages
  42.     return originalTitle?.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
  43. }
  44.  
  45. // -----------------------------------------------------------------------------------------------------
  46. // General Functions
  47. // -----------------------------------------------------------------------------------------------------
  48.  
  49. function addCss() {
  50.     if (!document.getElementById("custom-css-style")) {
  51.         GM_addStyle(`
  52.             /* all Badges */
  53.             [data-testid="hero-rating-bar__aggregate-rating"],
  54.             .rating-bar__base-button > .ipc-btn {
  55.                 padding: 4px 3px;
  56.                 border-radius: 5px !important;
  57.             }
  58.             .rating-bar__base-button {
  59.                 margin-right: 0 !important;
  60.             }
  61.  
  62.             /* added Badges */
  63.             span[data-testid=hero-rating-bar__aggregate-rating] {
  64.                 margin: 0 3px;
  65.                 background-color: rgba(255, 255, 255, 0.08);
  66.             }
  67.             /* format rating content */
  68.             span[data-testid=hero-rating-bar__aggregate-rating] .ipc-btn__text > div > div {
  69.                  align-items: center;
  70.             }
  71.             /* remove /10 */
  72.             span[data-testid=hero-rating-bar__aggregate-rating] div[data-testid=hero-rating-bar__aggregate-rating__score] > span:nth-child(2) {
  73.                 display: none;
  74.             }
  75.             span[data-testid=hero-rating-bar__aggregate-rating] div[data-testid=hero-rating-bar__aggregate-rating__score] > span:nth-child(1) {
  76.                 padding-right: 0;
  77.             }
  78.  
  79.             /* IMDb Badge */
  80.             div[data-testid=hero-rating-bar__aggregate-rating] {
  81.                 /* margin-left: 6px; */
  82.             }
  83.  
  84.             /* Badge Header */
  85.             .rating-bar__base-button > div {
  86.                 letter-spacing: unset;
  87.             }
  88.             span.rating-bar__base-button[myanimelist] > div {
  89.                 letter-spacing: normal;
  90.             }
  91.             
  92.             /* for badges without rating data */
  93.             .disable-anchor {
  94.                 cursor: default !important;
  95.             }
  96.             .disable-anchor:before {
  97.                 background: unset !important;
  98.             }
  99.         `).setAttribute("id", "custom-css-style");
  100.     }
  101.     const imdbRatingName = document.querySelector('div[data-testid="hero-rating-bar__aggregate-rating"] > div');
  102.     if (imdbRatingName) {
  103.         imdbRatingName.textContent = "IMDb";
  104.     }
  105. }
  106.  
  107. // create the initial rating template
  108. function createRatingBadgeTemplate(ratingSource) {
  109.     const ratingElementImdb = document.querySelector('div[data-testid="hero-rating-bar__aggregate-rating"]');
  110.  
  111.     // ignore if the rating badge has already been created
  112.     if (!ratingElementImdb || document.querySelector(`span.rating-bar__base-button[${ratingSource}]`)) return null;
  113.  
  114.     let clonedRatingBadge = ratingElementImdb.cloneNode(true);
  115.     clonedRatingBadge.setAttribute(ratingSource, "");
  116.     clonedRatingBadge.childNodes[0].innerText = ratingSource;
  117.  
  118.     // disable link per default
  119.     clonedRatingBadge.querySelector("a").removeAttribute("href");
  120.     // clonedRatingBadge.querySelector("a").classList.add("disable-anchor");
  121.  
  122.     const updateRatingElement = (element, rating, voteCount) => {
  123.         let imdbRatingElement = element.querySelector("div[data-testid=hero-rating-bar__aggregate-rating__score]");
  124.         if (imdbRatingElement) {
  125.             imdbRatingElement.querySelector("span").innerText = rating;
  126.             imdbRatingElement.nextSibling.nextSibling.innerText = voteCount;
  127.         }
  128.     };
  129.  
  130.     if (ratingSource === "Metacritic") {
  131.         const criticRatingElement = clonedRatingBadge.querySelector(
  132.             "div[data-testid=hero-rating-bar__aggregate-rating__score]"
  133.         )?.parentElement;
  134.  
  135.         if (!criticRatingElement) {
  136.             console.error("Critic rating element not found");
  137.             return;
  138.         }
  139.  
  140.         // Critic rating: replace star svg element with critic rating by cloning the rating element
  141.         let criticRating = clonedRatingBadge
  142.             .querySelector("div[data-testid=hero-rating-bar__aggregate-rating__score]")
  143.             .parentElement.cloneNode(true);
  144.         criticRating.classList.add("critic-rating");
  145.         clonedRatingBadge
  146.             .querySelector("div[data-testid=hero-rating-bar__aggregate-rating__score]")
  147.             .parentElement.classList.add("user-rating");
  148.  
  149.         //  critic rating
  150.         updateRatingElement(criticRating, undefinedValue, undefinedValue.toLowerCase());
  151.         criticRating.title = "Metascore";
  152.         criticRating.style.cssText = `
  153.         background-color: rgba(255, 255, 255, 0.1);
  154.         padding-left: 4px;
  155.         padding-right: 2px;
  156.         margin-right: 4px;
  157.         border-radius: 5px;
  158.         `;
  159.         clonedRatingBadge.querySelector("a > span > div > div").outerHTML = criticRating.outerHTML;
  160.  
  161.         // user rating
  162.         updateRatingElement(clonedRatingBadge.querySelector(".user-rating"), undefinedValue, undefinedValue.toLowerCase());
  163.         clonedRatingBadge.querySelector(".user-rating").title = "User Score";
  164.         clonedRatingBadge.querySelector(".user-rating").style.paddingRight = "0";
  165.     } else {
  166.         updateRatingElement(clonedRatingBadge, undefinedValue, undefinedValue.toLowerCase());
  167.         clonedRatingBadge.querySelector("a > span > div > div").remove();
  168.         clonedRatingBadge.querySelector(".ipc-btn__text > div > div").style.paddingRight = "0";
  169.     }
  170.  
  171.     // convert div to span element, otherwise it will be removed from IMDb scripts
  172.     const ratingElement = document.createElement("span");
  173.     // Transfer all attributes from the cloned div element to the new span element
  174.     for (let attr of clonedRatingBadge.attributes) {
  175.         ratingElement.setAttribute(attr.name, attr.value);
  176.     }
  177.     // transfer the content of the cloned IMDb rating element to the new span element
  178.     ratingElement.innerHTML = clonedRatingBadge.innerHTML;
  179.  
  180.     ratingElementImdb.insertAdjacentElement("beforebegin", ratingElement);
  181.     return ratingElement;
  182. }
  183.  
  184. // update the rating template with actual data
  185. function updateRatingTemplate(newRatingBadge, ratingData) {
  186.     if (!newRatingBadge || !ratingData) return;
  187.  
  188.     const selectors = {
  189.         url: "a",
  190.         generalRating: "div[data-testid=hero-rating-bar__aggregate-rating__score] > span",
  191.         generalVoteCount: "div[data-testid=hero-rating-bar__aggregate-rating__score] + * + *",
  192.         criticRating: ".critic-rating div[data-testid=hero-rating-bar__aggregate-rating__score] > span",
  193.         criticVoteCount: ".critic-rating div[data-testid=hero-rating-bar__aggregate-rating__score] + * + *",
  194.         userRating: ".user-rating div[data-testid=hero-rating-bar__aggregate-rating__score] > span",
  195.         userVoteCount: ".user-rating div[data-testid=hero-rating-bar__aggregate-rating__score] + * + *",
  196.     };
  197.  
  198.     function updateElement(selector, value, voteCount = 0) {
  199.         const element = newRatingBadge.querySelector(selector);
  200.  
  201.         if (!voteCount) {
  202.             element.textContent = value !== undefined && value !== 0 ? value : undefinedValue;
  203.         } else {
  204.             element.textContent = value !== undefined && value !== 0 ? value : undefinedValue.toLowerCase();
  205.         }
  206.     }
  207.  
  208.     newRatingBadge.querySelector(selectors.url).href = ratingData.url;
  209.     // newRatingBadge.querySelector(selectors.url).classList.remove("disable-anchor");
  210.  
  211.     if (ratingData.source === "Metacritic") {
  212.         updateElement(selectors.criticRating, ratingData.criticRating);
  213.         updateElement(selectors.userRating, ratingData.userRating);
  214.         updateElement(selectors.criticVoteCount, ratingData.criticVoteCount, 1);
  215.         updateElement(selectors.userVoteCount, ratingData.userVoteCount, 1);
  216.     } else {
  217.         updateElement(selectors.generalRating, ratingData.rating);
  218.         updateElement(selectors.generalVoteCount, ratingData.voteCount, 1);
  219.     }
  220. }
  221.  
  222. // -----------------------------------------------------------------------------------------------------
  223. // TMDB
  224. // -----------------------------------------------------------------------------------------------------
  225.  
  226. let tmdbDataPromise = null;
  227. async function getTmdbData() {
  228.     const configured = await GM_getValue("TMDB", false);
  229.     if (!configured) return;
  230.  
  231.     if (tmdbDataPromise) return tmdbDataPromise;
  232.  
  233.     if (!imdbId) {
  234.         throw new Error("IMDb ID not found in URL.");
  235.     }
  236.  
  237.     const options = {
  238.         method: "GET",
  239.         headers: {
  240.             accept: "application/json",
  241.             Authorization:
  242.                 "Bearer eyJhbGciOiJIUzI1NiJ9.eyJhdWQiOiIyMzc1ZGIzOTYwYWVhMWI1OTA1NWMwZmM3ZDcwYjYwZiIsInN1YiI6IjYwYmNhZTk0NGE0YmY2MDA1OWJhNWE1ZSIsInNjb3BlcyI6WyJhcGlfcmVhZCJdLCJ2ZXJzaW9uIjoxfQ.DU51juQWlAIIfZ2lK99b3zi-c5vgc4jAwVz5h2WjOP8",
  243.         },
  244.     };
  245.  
  246.     tmdbDataPromise = fetch(`https://api.themoviedb.org/3/find/${imdbId}?external_source=imdb_id`, options)
  247.         .then((response) => {
  248.             if (!response.ok) {
  249.                 throw new Error(`HTTP error! status: ${response.status}`);
  250.             }
  251.             return response.json();
  252.         })
  253.         .then((data) => {
  254.             const result = data.movie_results[0] || data.tv_results[0];
  255.             if (!result) {
  256.                 throw new Error("No data found for the provided IMDb ID.");
  257.             }
  258.  
  259.             console.log("TMDB: ", result);
  260.             return {
  261.                 source: "TMDB",
  262.                 id: result.id,
  263.                 rating: (Math.round(result.vote_average * 10) / 10).toLocaleString(local, {
  264.                     minimumFractionDigits: 1,
  265.                     maximumFractionDigits: 1,
  266.                 }),
  267.                 voteCount: result.vote_count?.toLocaleString(local),
  268.                 url: `https://www.themoviedb.org/${result.media_type}/${result.id}`,
  269.             };
  270.         })
  271.         .catch((error) => {
  272.             console.error("Error fetching TMDb data:", error);
  273.             return 0;
  274.         });
  275.  
  276.     return tmdbDataPromise;
  277. }
  278.  
  279. async function addTmdbRatingBadge() {
  280.     const configured = await GM_getValue("TMDB", false);
  281.     if (!configured) return;
  282.  
  283.     const newRatingBadge = createRatingBadgeTemplate("TMDB");
  284.  
  285.     // if the template for the rating badge was not created, it already exists
  286.     if (!newRatingBadge) return;
  287.  
  288.     const ratingData = await getTmdbData();
  289.  
  290.     // Copy ratingData to avoid modifying the original object
  291.     let finalRatingData = { ...ratingData };
  292.  
  293.     // Check if ratingData or ratingData.url is undefined and provide a default value
  294.     if (!ratingData?.url) {
  295.         const searchTitle = getOriginalTitle() ?? getMainTitle();
  296.         const defaultUrl = `https://www.themoviedb.org/search?query=${searchTitle}`;
  297.         finalRatingData.url = defaultUrl;
  298.     }
  299.  
  300.     updateRatingTemplate(newRatingBadge, finalRatingData);
  301. }
  302.  
  303. // -----------------------------------------------------------------------------------------------------
  304. // Douban
  305. // -----------------------------------------------------------------------------------------------------
  306.  
  307. let doubanDataPromise = null;
  308. async function getDoubanData() {
  309.     const configured = await GM_getValue("Douban", false);
  310.     if (!configured) return;
  311.  
  312.     if (doubanDataPromise) return doubanDataPromise;
  313.  
  314.     if (!imdbId) {
  315.         throw new Error("IMDb ID not found in URL.");
  316.     }
  317.  
  318.     const fetchFromDouban = (url, method = "GET", data = null) =>
  319.         new Promise((resolve, reject) => {
  320.             GM.xmlHttpRequest({
  321.                 method,
  322.                 url,
  323.                 data,
  324.                 headers: {
  325.                     "Content-Type": "application/x-www-form-urlencoded; charset=utf8",
  326.                 },
  327.                 onload: (response) => {
  328.                     if (response.status >= 200 && response.status < 400) {
  329.                         resolve(JSON.parse(response.responseText));
  330.                     } else {
  331.                         console.error(`Error getting ${url}:`, response.status, response.statusText, response.responseText);
  332.                         resolve(null);
  333.                     }
  334.                 },
  335.                 onerror: (error) => {
  336.                     console.error(`Error during GM.xmlHttpRequest to ${url}:`, error.statusText);
  337.                     reject(error);
  338.                 },
  339.             });
  340.         });
  341.  
  342.     const getDoubanInfo = async (imdbId) => {
  343.         const data = await fetchFromDouban(
  344.             `https://api.douban.com/v2/movie/imdb/${imdbId}`,
  345.             "POST",
  346.             "apikey=0ac44ae016490db2204ce0a042db2916"
  347.         );
  348.         if (data && data.alt && data.alt !== "N/A") {
  349.             const url = data.alt.replace("/movie/", "/subject/") + "/";
  350.             return { url, rating: data.rating, title: data.title };
  351.         }
  352.     };
  353.  
  354.     doubanDataPromise = (async function () {
  355.         try {
  356.             const result = await getDoubanInfo(imdbId);
  357.             if (!result) {
  358.                 throw new Error("No data found for the provided IMDb ID.");
  359.             }
  360.  
  361.             console.log("Douban: ", result);
  362.             return {
  363.                 source: "Douban",
  364.                 id: result.id,
  365.                 rating: Number(result.rating.average).toLocaleString(local, { minimumFractionDigits: 1, maximumFractionDigits: 1 }),
  366.                 voteCount: result.rating.numRaters?.toLocaleString(local),
  367.                 url: result.url,
  368.             };
  369.         } catch (error) {
  370.             console.error("Error fetching Douban data:", error);
  371.             return 0;
  372.         }
  373.     })();
  374.  
  375.     return doubanDataPromise;
  376. }
  377.  
  378. async function addDoubanRatingBadge() {
  379.     const configured = await GM_getValue("Douban", false);
  380.     if (!configured) return;
  381.  
  382.     const newRatingBadge = createRatingBadgeTemplate("Douban");
  383.  
  384.     // if the template for the rating badge was not created, it already exists
  385.     if (!newRatingBadge) return;
  386.  
  387.     const ratingData = await getDoubanData();
  388.  
  389.     // Copy ratingData to avoid modifying the original object
  390.     let finalRatingData = { ...ratingData };
  391.  
  392.     // Check if ratingData or ratingData.url is undefined and provide a default value
  393.     if (!ratingData?.url) {
  394.         const searchTitle = getOriginalTitle() ?? getMainTitle();
  395.         const defaultUrl = `https://search.douban.com/movie/subject_search?search_text=${searchTitle}`;
  396.         finalRatingData.url = defaultUrl;
  397.     }
  398.  
  399.     updateRatingTemplate(newRatingBadge, finalRatingData);
  400. }
  401.  
  402. // -----------------------------------------------------------------------------------------------------
  403. // Metacritic
  404. // -----------------------------------------------------------------------------------------------------
  405. // wikidata solution inspired by IMDb Scout Mod
  406.  
  407. let metacriticDataPromise = null;
  408. async function getMetacriticData() {
  409.     const configured = await GM_getValue("Metacritic", false);
  410.     if (!configured) return;
  411.  
  412.     if (metacriticDataPromise) return metacriticDataPromise;
  413.  
  414.     if (!imdbId) {
  415.         throw new Error("IMDb ID not found in URL.");
  416.     }
  417.  
  418.     async function getMetacriticId() {
  419.         return new Promise((resolve) => {
  420.             GM.xmlHttpRequest({
  421.                 method: "GET",
  422.                 timeout: 10000,
  423.                 headers: { "User-Agent": USER_AGENT },
  424.                 url: `https://query.wikidata.org/sparql?format=json&query=SELECT * WHERE {?s wdt:P345 "${imdbId}". OPTIONAL { ?s wdt:P1712 ?Metacritic_ID. }}`,
  425.                 onload: function (response) {
  426.                     const result = JSON.parse(response.responseText);
  427.                     const bindings = result.results.bindings[0];
  428.                     const metacriticId = bindings && bindings.Metacritic_ID ? bindings.Metacritic_ID.value : "";
  429.                     resolve(metacriticId);
  430.                 },
  431.                 onerror: function () {
  432.                     console.error("getMetacriticId: Request Error.");
  433.                     reject("Request Error");
  434.                 },
  435.                 onabort: function () {
  436.                     console.error("getMetacriticId: Request Aborted.");
  437.                     reject("Request Abort");
  438.                 },
  439.                 ontimeout: function () {
  440.                     console.error("getMetacriticId: Request Timeout.");
  441.                     reject("Request Timeout");
  442.                 },
  443.             });
  444.         });
  445.     }
  446.  
  447.     function fetchMetacriticData(url) {
  448.         return new Promise((resolve, reject) => {
  449.             GM.xmlHttpRequest({
  450.                 method: "GET",
  451.                 url: url,
  452.                 headers: { "User-Agent": USER_AGENT },
  453.                 onload: function (response) {
  454.                     const parser = new DOMParser();
  455.                     const result = parser.parseFromString(response.responseText, "text/html");
  456.  
  457.                     let criticRating;
  458.                     let userRating;
  459.                     let criticVoteCount;
  460.                     let userVoteCount;
  461.  
  462.                     const criticRatingElement = result.querySelector(".c-siteReviewScore");
  463.                     if (criticRatingElement) {
  464.                         const ratingText = criticRatingElement.textContent.trim();
  465.                         criticRating = ratingText.includes(".") ? "" : !isNaN(ratingText) ? ratingText : 0;
  466.  
  467.                         if (criticRating !== 0) {
  468.                             let criticVoteCountText = result
  469.                                 .querySelector(".c-siteReviewScore")
  470.                                 .parentElement.parentElement.parentElement.querySelector("a > span")?.textContent;
  471.                             criticVoteCount = criticVoteCountText.match(/\d+/)[0];
  472.                         } else {
  473.                             criticVoteCount = 0;
  474.                         }
  475.                     }
  476.  
  477.                     const userRatingElement = result.querySelector(".c-siteReviewScore_user");
  478.                     if (userRatingElement) {
  479.                         const ratingText = userRatingElement.textContent.trim();
  480.                         userRating = Number(ratingText).toLocaleString(local, { minimumFractionDigits: 1, maximumFractionDigits: 1 });
  481.  
  482.                         // if (!isNaN(ratingText)) userRating = ratingText * 10;
  483.  
  484.                         if (userRating !== 0) {
  485.                             let userVoteCountText = result
  486.                                 .querySelector(".c-siteReviewScore_user")
  487.                                 .parentElement.parentElement.parentElement.querySelector("a > span")?.textContent;
  488.                             userVoteCount = userVoteCountText.match(/\d+/)[0];
  489.                         } else {
  490.                             userVoteCount = 0;
  491.                         }
  492.                     }
  493.  
  494.                     console.log(
  495.                         "Critic rating: " +
  496.                             criticRating +
  497.                             ", User rating: " +
  498.                             userRating +
  499.                             ", Url: " +
  500.                             url +
  501.                             ", criticVoteCount: " +
  502.                             criticVoteCount +
  503.                             ", userVoteCount: " +
  504.                             userVoteCount
  505.                     );
  506.  
  507.                     // Resolve the promise with the ratings and URL
  508.                     resolve({
  509.                         source: "Metacritic",
  510.                         criticRating: criticRating,
  511.                         userRating: userRating,
  512.                         criticVoteCount: criticVoteCount,
  513.                         userVoteCount: userVoteCount,
  514.                         url: url,
  515.                     });
  516.                 },
  517.                 onerror: function () {
  518.                     console.log("getMetacriticRatings: Request Error.");
  519.                     reject("Request Error");
  520.                 },
  521.                 onabort: function () {
  522.                     console.log("getMetacriticRatings: Request is aborted.");
  523.                     reject("Request Aborted");
  524.                 },
  525.                 ontimeout: function () {
  526.                     console.log("getMetacriticRatings: Request timed out.");
  527.                     reject("Request Timed Out");
  528.                 },
  529.             });
  530.         });
  531.     }
  532.  
  533.     metacriticDataPromise = (async () => {
  534.         const metacriticId = await getMetacriticId();
  535.         const url = encodeURI(`https://www.metacritic.com/${metacriticId}`);
  536.  
  537.         if (metacriticId !== "") {
  538.             return fetchMetacriticData(url);
  539.         }
  540.     })();
  541.  
  542.     return 0;
  543. }
  544.  
  545. async function addMetacriticRatingBadge() {
  546.     const configured = await GM_getValue("Metacritic", false);
  547.     if (!configured) return;
  548.  
  549.     const newRatingBadge = createRatingBadgeTemplate("Metacritic");
  550.  
  551.     // if the template for the rating badge was not created, it already exists
  552.     if (!newRatingBadge) return;
  553.  
  554.     const ratingData = await getMetacriticData();
  555.  
  556.     // Copy ratingData to avoid modifying the original object
  557.     let finalRatingData = { ...ratingData };
  558.  
  559.     // Check if ratingData or ratingData.url is undefined and provide a default value
  560.     if (!ratingData?.url) {
  561.         const searchTitle = getOriginalTitle() ?? getMainTitle();
  562.         const defaultUrl = `https://www.metacritic.com/search/${searchTitle}`;
  563.         finalRatingData.url = defaultUrl;
  564.     }
  565.  
  566.     updateRatingTemplate(newRatingBadge, finalRatingData);
  567. }
  568.  
  569. // -----------------------------------------------------------------------------------------------------
  570. // MyAnimeList
  571. // -----------------------------------------------------------------------------------------------------
  572. // wikidata solution inspired by IMDb Scout Mod
  573.  
  574. let myAnimeListDataPromise = null;
  575. async function getMyAnimeListDataByImdbId() {
  576.     // only if genre is anime
  577.     const genreAnime = document.querySelector(".ipc-chip-list__scroller")?.textContent.includes("Anime");
  578.     if (!genreAnime) return;
  579.  
  580.     // only if enabled in settings
  581.     const configured = await GM_getValue("MyAnimeList", false);
  582.     if (!configured) return;
  583.  
  584.     if (myAnimeListDataPromise) return myAnimeListDataPromise;
  585.  
  586.     function getAnimeID() {
  587.         const url = `https://query.wikidata.org/sparql?format=json&query=SELECT * WHERE {?s wdt:P345 "${imdbId}". OPTIONAL {?s wdt:P4086 ?MyAnimeList_ID.} OPTIONAL {?s wdt:P8729 ?AniList_ID.}}`;
  588.  
  589.         return new Promise((resolve) => {
  590.             GM.xmlHttpRequest({
  591.                 method: "GET",
  592.                 timeout: 10000,
  593.                 url: url,
  594.                 headers: { "User-Agent": USER_AGENT },
  595.                 onload: function (response) {
  596.                     const result = JSON.parse(response.responseText);
  597.                     let myAnimeListId = "";
  598.                     let aniListId = "";
  599.                     if (result.results.bindings[0] !== undefined) {
  600.                         if (result.results.bindings[0].MyAnimeList_ID !== undefined) {
  601.                             myAnimeListId = result.results.bindings[0].MyAnimeList_ID.value;
  602.                         } else {
  603.                             console.log("getAnimeID: No MyAnimeList_ID found on wikidata.org");
  604.                         }
  605.                         if (result.results.bindings[0].AniList_ID !== undefined) {
  606.                             aniListId = result.results.bindings[0].AniList_ID.value;
  607.                         }
  608.                         console.log("getAnimeID: ", result.results);
  609.                         resolve([myAnimeListId, aniListId]);
  610.                     }
  611.                 },
  612.                 onerror: function () {
  613.                     console.log("getAnimeID: Request Error.");
  614.                     reject("Request Error");
  615.                 },
  616.                 onabort: function () {
  617.                     console.log("getAnimeID: Request Abort.");
  618.                     reject("Request Abort");
  619.                 },
  620.                 ontimeout: function () {
  621.                     console.log("getAnimeID: Request Timeout.");
  622.                     reject("Request Timeout");
  623.                 },
  624.             });
  625.         });
  626.     }
  627.  
  628.     function fetchMyAnimeListData(myAnimeListId) {
  629.         return new Promise((resolve, reject) => {
  630.             const url = "https://api.jikan.moe/v4/anime/" + myAnimeListId;
  631.             GM.xmlHttpRequest({
  632.                 method: "GET",
  633.                 timeout: 10000,
  634.                 url: url,
  635.                 headers: { "User-Agent": USER_AGENT },
  636.                 onload: function (response) {
  637.                     if (response.status === 200) {
  638.                         const result = JSON.parse(response.responseText);
  639.                         const rating = result.data.score;
  640.                         if (!isNaN(rating) && rating > 0) {
  641.                             console.log("fetchMyAnimeListData: ", result.data.mal_id, result);
  642.  
  643.                             resolve({
  644.                                 source: "MyAnimeList",
  645.                                 rating: parseFloat((rating || 0).toFixed(1)).toLocaleString(local),
  646.                                 voteCount: result.data.scored_by?.toLocaleString(local),
  647.                                 url: result.data.url,
  648.                             });
  649.                         } else {
  650.                             reject("Invalid rating");
  651.                         }
  652.                     } else {
  653.                         console.log("MyAnimeList: HTTP Error: " + response.status);
  654.                         reject("HTTP Error");
  655.                     }
  656.                 },
  657.                 onerror: function () {
  658.                     console.log("MyAnimeList: Request Error.");
  659.                     reject("Request Error");
  660.                 },
  661.                 onabort: function () {
  662.                     console.log("MyAnimeList: Request is aborted.");
  663.                     reject("Request Aborted");
  664.                 },
  665.                 ontimeout: function () {
  666.                     console.log("MyAnimeList: Request timed out.");
  667.                     reject("Request Timeout");
  668.                 },
  669.             });
  670.         });
  671.     }
  672.  
  673.     myAnimeListDataPromise = (async () => {
  674.         const id = await getAnimeID();
  675.         const myAnimeListId = id[0];
  676.         const aniListId = id[1];
  677.  
  678.         if (myAnimeListId !== "") {
  679.             return fetchMyAnimeListData(myAnimeListId);
  680.         }
  681.     })();
  682.  
  683.     return 0;
  684. }
  685.  
  686. async function getMyAnimeListDataByTitle() {
  687.     const titleElement = getTitleElement();
  688.     if (!titleElement) return;
  689.  
  690.     // only if genre is anime
  691.     const genreAnime = document.querySelector(".ipc-chip-list__scroller")?.textContent.includes("Anime");
  692.     if (!genreAnime) return;
  693.  
  694.     const mainTitle = getMainTitle();
  695.     const originalTitle = getOriginalTitle();
  696.  
  697.     const metaData = titleElement?.parentElement?.querySelector("ul");
  698.     const metaItems = metaData?.querySelectorAll("li");
  699.     // If the text content type is an integer, it is a tv show, otherwise it is a movie.
  700.     const type = isNaN(metaItems?.[0]?.textContent) ? "tv" : "movie";
  701.     const yearIndex = type === "tv" ? 1 : 0;
  702.     const yearText = metaItems?.[yearIndex]?.textContent;
  703.     // Extract the first number up to the non-number sign and convert it into a integer (2018-2020)
  704.     const year = parseInt(yearText);
  705.  
  706.     async function fetchAllPages(searchTitle) {
  707.         let currentPage = 1;
  708.         let allResults = [];
  709.         const maxRetries = 3;
  710.         const retryDelay = 1000; // 5 seconds
  711.  
  712.         async function fetchWithRetry(url, retries = 0) {
  713.             try {
  714.                 const response = await fetch(url);
  715.                 if (response.status === 429) {
  716.                     if (retries < maxRetries) {
  717.                         console.log(`Rate limited. Retrying in ${retryDelay / 1000} seconds...`);
  718.                         await new Promise((resolve) => setTimeout(resolve, retryDelay));
  719.                         return fetchWithRetry(url, retries + 1);
  720.                     } else {
  721.                         throw new Error("Max retries reached. Please try again later.");
  722.                     }
  723.                 }
  724.                 return response;
  725.             } catch (error) {
  726.                 console.error("Fetch error:", error);
  727.                 throw error;
  728.             }
  729.         }
  730.  
  731.         while (true) {
  732.             try {
  733.                 const response = await fetchWithRetry(
  734.                     `https://api.jikan.moe/v4/anime?q=${encodeURIComponent(searchTitle)}&type=${type}&page=${currentPage}`
  735.                 );
  736.                 const data = await response.json();
  737.                 allResults = allResults.concat(data.data);
  738.                 if (!data.pagination.has_next_page) break;
  739.                 currentPage++;
  740.             } catch (error) {
  741.                 console.error("Error fetching data:", error);
  742.                 break;
  743.             }
  744.         }
  745.         // console.log(searchTitle, year, type, allResults);
  746.  
  747.         const result = allResults.find((anime, index) => {
  748.             const titleMatch = anime.title.toLowerCase().includes(searchTitle.toLowerCase());
  749.             const yearMatch = anime.aired.prop.from.year === year;
  750.  
  751.             if (titleMatch && yearMatch) {
  752.                 // console.log(`Title and year match found for anime[${index}] - ${anime.title}`);
  753.                 return true;
  754.             }
  755.  
  756.             if (!titleMatch && anime.title_english) {
  757.                 const englishTitleMatch = anime.title_english.toLowerCase().includes(searchTitle.toLowerCase());
  758.                 // console.log(`English title match for "${anime.title_english}": ${englishTitleMatch}`);
  759.  
  760.                 if (englishTitleMatch && yearMatch) {
  761.                     // console.log(`English title and year match found for anime[${index}] - ${anime.title}`);
  762.                     return true;
  763.                 }
  764.             }
  765.  
  766.             if (!titleMatch && anime.title_synonyms && anime.title_synonyms.length > 0) {
  767.                 // console.log(`Checking synonyms for anime[${index}] - ${anime.title}, Synonyms: ${anime.title_synonyms}`);
  768.  
  769.                 const synonymMatch = anime.title_synonyms.some((synonym) => synonym.toLowerCase().includes(searchTitle.toLowerCase()));
  770.  
  771.                 // console.log(`Synonym match for anime[${index}] - ${anime.title}: ${synonymMatch}`);
  772.  
  773.                 if (synonymMatch && yearMatch) {
  774.                     // console.log(`Synonym and year match found for anime[${index}] - ${anime.title}`);
  775.                     return true;
  776.                 }
  777.             }
  778.  
  779.             // console.log(`No match found for anime[${index}] - ${anime.title}`);
  780.             return false;
  781.         });
  782.         return result;
  783.     }
  784.  
  785.     async function getAnimeData() {
  786.         try {
  787.             let result = await fetchAllPages(mainTitle);
  788.  
  789.             if (!result && originalTitle) {
  790.                 console.log(`No results found for "${mainTitle}", retrying with originalTitle "${originalTitle}"...`);
  791.                 result = await fetchAllPages(originalTitle);
  792.             }
  793.  
  794.             if (result) {
  795.                 console.log("getMyAnimeListDataByTitle: ", result);
  796.                 return result;
  797.             } else {
  798.                 console.log("No results found for either title.");
  799.                 return null;
  800.             }
  801.         } catch (error) {
  802.             console.error("Error retrieving data:", error);
  803.             return null;
  804.         }
  805.     }
  806.  
  807.     myAnimeListDataPromise = (async () => {
  808.         const anime = await getAnimeData();
  809.  
  810.         if (anime) {
  811.             const data = {
  812.                 source: "MyAnimeList",
  813.                 rating: Number(anime.score).toLocaleString(local, { minimumFractionDigits: 1, maximumFractionDigits: 1 }),
  814.                 voteCount: anime.scored_by?.toLocaleString(local),
  815.                 url: anime.url,
  816.             };
  817.  
  818.             // console.log("myAnimeListDataPromise: ", anime);
  819.  
  820.             return data;
  821.         } else {
  822.             console.log("No anime data found.");
  823.             return null;
  824.         }
  825.     })();
  826. }
  827.  
  828. async function addMyAnimeListRatingBadge() {
  829.     // only if genre is anime
  830.     const genreAnime = document.querySelector(".ipc-chip-list__scroller")?.textContent.includes("Anime");
  831.     if (!genreAnime) return;
  832.  
  833.     // only if enabled in settings
  834.     const configured = await GM_getValue("MyAnimeList", false);
  835.     if (!configured) return;
  836.  
  837.     const newRatingBadge = createRatingBadgeTemplate("MyAnimeList");
  838.  
  839.     // if the template for the rating badge was not created, it already exists
  840.     if (!newRatingBadge) return;
  841.  
  842.     let ratingData = await getMyAnimeListDataByImdbId();
  843.     if (ratingData === 0) {
  844.         ratingData = await getMyAnimeListDataByTitle();
  845.     }
  846.  
  847.     // Copy ratingData to avoid modifying the original object
  848.     let finalRatingData = { ...ratingData };
  849.  
  850.     // Check if ratingData or ratingData.url is undefined and provide a default value
  851.     if (!ratingData?.url) {
  852.         const searchTitle = getOriginalTitle() ?? getMainTitle();
  853.         const defaultUrl = `https://myanimelist.net/anime.php?q=${searchTitle}`; // Define your default URL here
  854.         finalRatingData.url = defaultUrl;
  855.     }
  856.  
  857.     updateRatingTemplate(newRatingBadge, finalRatingData);
  858. }
  859.  
  860. // -----------------------------------------------------------------------------------------------------
  861.  
  862. async function addDdl() {
  863.     const authorsMode = await GM_getValue("authorsMode", false);
  864.     if (!authorsMode) return;
  865.  
  866.     const targetElement = document.querySelector("[data-testid=hero__pageTitle]");
  867.  
  868.     if (!document.querySelector("a#ddl-button") && targetElement) {
  869.         let ddlElement = document.createElement("a");
  870.         ddlElement.id = "ddl-button";
  871.         ddlElement.href = `https://ddl-warez.cc/?s=${imdbId}`;
  872.         ddlElement.style.float = "right";
  873.  
  874.         let imgElement = document.createElement("img");
  875.         imgElement.src = "https://ddl-warez.cc/wp-content/uploads/logo.png";
  876.         imgElement.style.height = "48px";
  877.         imgElement.style.aspectRatio = "1/1";
  878.  
  879.         ddlElement.appendChild(imgElement);
  880.  
  881.         targetElement.insertAdjacentElement("afterend", ddlElement);
  882.     }
  883. }
  884.  
  885. let metadataAsText = "";
  886. function collectMetadataForClipboard() {
  887.     let title = document.querySelector("span.hero__primary-text")?.textContent;
  888.     let genres = document.querySelector("div[data-testid='interests'] div.ipc-chip-list__scroller")?.childNodes;
  889.     let additionalMetadata = document.querySelector('[data-testid="hero__pageTitle"]')?.parentElement?.querySelector("ul");
  890.  
  891.     // if click listener does not exist
  892.     if (!document.querySelector("ul.collectMetadataForClipboardListener") && title && genres && additionalMetadata) {
  893.         if (genres && additionalMetadata) {
  894.             if (metadataAsText === "") {
  895.                 // add title
  896.                 metadataAsText += title + " | ";
  897.                 // collect additional metadata
  898.                 for (let element of additionalMetadata?.childNodes) metadataAsText += element.textContent + " | ";
  899.                 // collect genres
  900.                 let iteration = genres?.length;
  901.                 for (let genre of genres) {
  902.                     metadataAsText += genre.textContent;
  903.  
  904.                     // append "," as long as not last iteration
  905.                     if (--iteration) metadataAsText += ", ";
  906.                 }
  907.             }
  908.  
  909.             additionalMetadata.style.cursor = "pointer";
  910.             additionalMetadata.addEventListener("click", function () {
  911.                 navigator.clipboard.writeText(metadataAsText);
  912.             });
  913.  
  914.             // to know if click listener is still there
  915.             additionalMetadata.classList.add("collectMetadataForClipboardListener");
  916.         }
  917.     }
  918. }
  919.  
  920. // Configuration Modal
  921. function openConfiguration() {
  922.     GM_addStyle(`
  923.     .modal-overlay {
  924.         position: fixed;
  925.         top: 0;
  926.         left: 0;
  927.         width: 100vw;
  928.         height: 100vh;
  929.         background-color: rgba(0, 0, 0, 0.5);
  930.         z-index: 9998;
  931.         transition: background-color 0.5s ease;
  932.     }
  933.     
  934.     .modal {
  935.         font-family: var(--ipt-font-family);
  936.         position: fixed;
  937.         top: 50%;
  938.         left: 50%;
  939.         transform: translate(-50%, -50%);
  940.         width: 300px;
  941.         padding: 20px;
  942.         background-color: #fff;
  943.         border-radius: 10px;
  944.         box-shadow: 0px 4px 8px rgba(0, 0, 0, 0.1);
  945.         z-index: 9999;
  946.         opacity: 0;
  947.         transition: opacity 0.5s ease;
  948.     }
  949.     
  950.     .modal-title {
  951.         margin-bottom: 20px;
  952.         font-size: 16px;
  953.         font-weight: bold;
  954.     }
  955.     
  956.     .checkbox-label {
  957.         display: block;
  958.         margin-bottom: 10px;
  959.     }
  960.     
  961.     .close-button {
  962.         display: block;
  963.         margin: 20px auto 0;
  964.     }
  965.     `);
  966.  
  967.     // Darken background
  968.     const overlay = document.createElement("div");
  969.     overlay.className = "modal-overlay";
  970.     overlay.style.backgroundColor = "rgba(0, 0, 0, 0)";
  971.     setTimeout(() => {
  972.         overlay.style.backgroundColor = "rgba(0, 0, 0, 0.5)";
  973.     }, 50);
  974.  
  975.     // Create modal
  976.     const modal = document.createElement("div");
  977.     modal.className = "modal";
  978.     setTimeout(() => {
  979.         modal.style.opacity = "1";
  980.     }, 50);
  981.  
  982.     // Title of the modal
  983.     const title = document.createElement("h3");
  984.     title.innerText = "Which ratings should be displayed?";
  985.     title.className = "modal-title";
  986.     modal.appendChild(title);
  987.  
  988.     // Add checkboxes
  989.     ratingSources.forEach((ratingSource) => {
  990.         const label = document.createElement("label");
  991.         label.className = "checkbox-label";
  992.  
  993.         const checkbox = document.createElement("input");
  994.         checkbox.type = "checkbox";
  995.         checkbox.checked = GM_getValue(ratingSource, false);
  996.  
  997.         checkbox.addEventListener("change", () => {
  998.             GM_setValue(ratingSource, checkbox.checked);
  999.             if (!checkbox.checked) {
  1000.                 document.querySelector(`span.rating-bar__base-button[${ratingSource}]`).remove();
  1001.             } else {
  1002.                 // trigger observer to add new badges
  1003.                 const tempElement = document.createElement("div");
  1004.                 document.body.appendChild(tempElement);
  1005.                 document.body.removeChild(tempElement);
  1006.             }
  1007.         });
  1008.  
  1009.         label.appendChild(checkbox);
  1010.         label.appendChild(document.createTextNode(` ${ratingSource}`));
  1011.         modal.appendChild(label);
  1012.     });
  1013.  
  1014.     // Add button to close
  1015.     const closeButton = document.createElement("button");
  1016.     closeButton.innerText = "Close";
  1017.     closeButton.className =
  1018.         "close-button ipc-btn ipc-btn--half-padding ipc-btn--default-height ipc-btn--core-accent1 ipc-btn--theme-baseAlt ";
  1019.  
  1020.     closeButton.addEventListener("click", () => {
  1021.         document.body.removeChild(overlay);
  1022.         document.body.removeChild(modal);
  1023.     });
  1024.  
  1025.     modal.appendChild(closeButton);
  1026.  
  1027.     // Add modal and overlay to the DOM
  1028.     document.body.appendChild(overlay);
  1029.     document.body.appendChild(modal);
  1030.  
  1031.     // Close modal on click outside
  1032.     overlay.addEventListener("click", () => {
  1033.         document.body.removeChild(overlay);
  1034.         document.body.removeChild(modal);
  1035.     });
  1036. }
  1037.  
  1038. // add and keep elements in header container
  1039. async function main() {
  1040.     // set default configuration
  1041.     ratingSources.forEach((badge) => {
  1042.         // Query default value (if does not exist, 'null' is returned)
  1043.         const existingValue = GM_getValue(badge, null);
  1044.         if (existingValue === null) {
  1045.             // Value does not exist, set default value to true
  1046.             GM_setValue(badge, true);
  1047.         }
  1048.     });
  1049.  
  1050.     // ignore episode view
  1051.     if (!document.title.includes('"')) {
  1052.         addCss();
  1053.         getTmdbData();
  1054.         getDoubanData();
  1055.         getMetacriticData();
  1056.         getMyAnimeListDataByImdbId();
  1057.         getMyAnimeListDataByTitle();
  1058.  
  1059.         const observer = new MutationObserver(async () => {
  1060.             addCss();
  1061.             await addMyAnimeListRatingBadge();
  1062.             await addMetacriticRatingBadge();
  1063.             await addDoubanRatingBadge();
  1064.             await addTmdbRatingBadge();
  1065.  
  1066.             addDdl();
  1067.             // addGenresToTitle();
  1068.             collectMetadataForClipboard();
  1069.         });
  1070.  
  1071.         observer.observe(document.documentElement, { childList: true, subtree: true });
  1072.     }
  1073. }
  1074.  
  1075. // -----------------------------------------------------------------------------------------------------
  1076. // Main
  1077. // -----------------------------------------------------------------------------------------------------
  1078.  
  1079. main();
  1080. // GM_setValue("authorsMode", true);