☰

Greasy Fork is available in English.

Itch.io Web Integration

Shows if an Itch.io link has been claimed or not

2020-06-09 يوللانغان نەشرى. ئەڭ يېڭى نەشرىنى كۆرۈش.

  1. // ==UserScript==
  2. // @name        Itch.io Web Integration
  3. // @namespace   Lex@GreasyFork
  4. // @match       *://*/*
  5. // @grant       GM_xmlhttpRequest
  6. // @grant       GM_getValue
  7. // @grant       GM_setValue
  8. // @version     0.1.8.4
  9. // @author      Lex
  10. // @description Shows if an Itch.io link has been claimed or not
  11. // @connect     itch.io
  12. // ==/UserScript==
  13.  
  14. (function(){
  15.     'use strict';
  16.  
  17.     const CACHE_VERSION_KEY = "CacheVersion";
  18.     const INVALIDATION_TIME = 5*60*60*1000; // 5 hour cache time
  19.     const ITCH_GAME_CACHE_KEY = 'ItchGameCache';
  20.     var ItchGameCache;
  21.     
  22.     // Promise wrapper for GM_xmlhttpRequest
  23.     const Request = details => new Promise((resolve, reject) => {
  24.         details.onerror = details.ontimeout = reject;
  25.         details.onload = resolve;
  26.         GM_xmlhttpRequest(details);
  27.     });
  28.     
  29.     function versionCacheInvalidator() {
  30.         const sVersion = v => {
  31.             if (typeof v !== 'string' || !v.match(/\d+\.\d+/)) return 0;
  32.             return parseFloat(v.match(/\d+\.\d+/)[0]);
  33.         }
  34.         const prev = sVersion(GM_getValue(CACHE_VERSION_KEY, '0.0'));
  35.         if (prev < 0.1) {
  36.             console.log(`${GM_info.script.version} > ${prev}`);
  37.             console.log(`New minor version of ${GM_info.script.name} detected. Invalidating cache.`)
  38.             _clearItchCache();
  39.         }
  40.         GM_setValue(CACHE_VERSION_KEY, GM_info.script.version);
  41.     }
  42.     
  43.     function _clearItchCache() {
  44.         ItchGameCache = {};
  45.         _saveItchCache();
  46.     }
  47.     
  48.     function loadItchCache() {
  49.         ItchGameCache = JSON.parse(GM_getValue(ITCH_GAME_CACHE_KEY, '{}'));
  50.     }
  51.     
  52.     function _saveItchCache() {
  53.         if (ItchGameCache === undefined) return;
  54.         GM_setValue(ITCH_GAME_CACHE_KEY, JSON.stringify(ItchGameCache));
  55.     }
  56.     
  57.     function setItchGameCache(key, game) {
  58.         loadItchCache(); // refresh our cache in case another tab has edited it
  59.         ItchGameCache[key] = game;
  60.         _saveItchCache();
  61.     }
  62.     
  63.     function deleteItchGameCache(key) {
  64.         if (key === undefined) return;
  65.         loadItchCache();
  66.         delete ItchGameCache[key];
  67.         _saveItchCache();
  68.     }
  69.     
  70.     function getItchGameCache(link) {
  71.         if (!ItchGameCache) loadItchCache();
  72.         if (Object.prototype.hasOwnProperty.call(ItchGameCache, link)) {
  73.             return ItchGameCache[link];
  74.         }
  75.         return null;
  76.     }
  77.     
  78.     async function claimGame(url) {
  79.         const parser = new DOMParser();
  80.         
  81.         const purchase_url = url + "/purchase";
  82.         console.log("Getting purchase page: " + purchase_url);
  83.         const purchase_resp = await Request({method: "GET", url: purchase_url});
  84.         const purchase_dom = parser.parseFromString(purchase_resp.responseText, 'text/html');
  85.         const download_csrf_token = purchase_dom.querySelector("form.form").csrf_token.value;
  86.         
  87.         const download_url_resp = await Request({
  88.             method: "POST",
  89.             url: url + "/download_url",
  90.             headers: {
  91.                 "Content-Type": "application/x-www-form-urlencoded"
  92.             },
  93.             data: 'csrf_token='+encodeURIComponent(download_csrf_token)
  94.         });
  95.         const downloadUrl = JSON.parse(download_url_resp.responseText).url;
  96.         console.log("Received download url: " + downloadUrl);
  97.  
  98.         const download_resp = await Request({method: "GET", url: downloadUrl});
  99.         const dom = parser.parseFromString(download_resp.responseText, 'text/html');
  100.         const claimForm = dom.querySelector(".claim_to_download_box form");
  101.         const claim_csrf_token = claimForm.csrf_token.value;
  102.         const claim_key_url = claimForm.action;
  103.  
  104.         console.log("Claiming game using " + claim_key_url);
  105.         const claim_key_resp = await Request({
  106.             method: "POST",
  107.             url: claim_key_url,
  108.             headers: {
  109.                 "Content-Type": "application/x-www-form-urlencoded"
  110.             },
  111.             data: 'csrf_token='+encodeURIComponent(claim_csrf_token)
  112.         });
  113.         return /You claimed this/.test(claim_key_resp.responseText);
  114.     }
  115.     
  116.     // Parses a DOM into a game object
  117.     function parsePage(url, dom) {
  118.         // Gets the inner text of an element if it can be found otherwise returns undefined
  119.         const txt = query => { const e = dom.querySelector(query); return e && e.innerText.trim(); };
  120.         
  121.         const game = {};
  122.         
  123.         game.cachetime = (new Date()).getTime();
  124.         game.url = url;
  125.         game.title = txt('h1.game_title');
  126.         
  127.         game.isOwned = dom.querySelector(".purchase_banner_inner .key_row .ownership_reason") !== null;        
  128.         game.isClaimable = [...dom.querySelectorAll(".buy_btn")].filter(e => e.innerText == "Download or claim").length > 0;
  129.         game.isFree = [...dom.querySelectorAll("span[itemprop=price]")].filter(e => e.innerText === "$0.00 USD").length > 0;
  130.         game.hasPurchase = [...dom.querySelectorAll("span[itemprop=price]")].filter(e => e.innerText !== "$0.00 USD").length > 0;
  131.         game.hasFreeDownload = [...dom.querySelectorAll("a.download_btn,a.buy_btn")].filter(e => e.innerText == "Download" || e.innerText == "Download Now").length > 0;
  132.         game.hasCommunityCopies = document.querySelector(".reward_footer") !== null;
  133.         const copiesBlock = document.querySelector(".remaining_count");
  134.         game.communityCopies = copiesBlock && copiesBlock.innerText.match(/\d+/) && copiesBlock.innerText.match(/\d+/)[0];
  135.         game.communityCopies = game.communityCopies || 0;
  136.         game.original_price = txt("span.original_price");
  137.         game.price = txt("span[itemprop=price]");
  138.         game.saleRate = txt(".sale_rate");
  139.         game.breadcrumbs = txt(".breadcrumbs");
  140.         return game;
  141.     }
  142.     
  143.     // Sends an XHR request and parses the results into a game object
  144.     async function fetchItchGame(url) {
  145.         const response = await Request({method: "GET",
  146.                                  url: url});
  147.         if (response.status != 200) {
  148.             console.log(`Error ${response.status} fetching page ${url}`);
  149.             return null;
  150.         }
  151.         const parser = new DOMParser();
  152.         const dom = parser.parseFromString(response.responseText, 'text/html');
  153.         return parsePage(url, dom);
  154.     }
  155.     
  156.     // Loads an itch game from cache or fetches the page if needed
  157.     async function getItchGame(url) {
  158.         let game = getItchGameCache(url);
  159.         if (game !== null) {
  160.             const isExpired = (new Date()).getTime() - game.cachetime > INVALIDATION_TIME;
  161.             // Expiration checking currently disabled
  162.             /*if (isExpired) {
  163.                 game = null;
  164.             }*/
  165.         }
  166.         if (game === null) {
  167.             game = await fetchItchGame(url);
  168.             if (game !== null)
  169.                 setItchGameCache(url, game);
  170.         }
  171.         return game;
  172.     }
  173.     
  174.     async function claimClicked(a, game) {
  175.         console.log("Attempting to claim " + game.url);
  176.         a.innerText += ' ⌛';
  177.         a.onclick = null;
  178.         const success = await claimGame(game.url);
  179.         if (success === true) {
  180.             a.style.display = "none";
  181.             const ownMark = a.parentElement.firstChild;
  182.             ownMark.innerHTML = `<span title="Successfully claimed">✔️</span>`;
  183.             deleteItchGameCache(game.url);
  184.         } else {
  185.             a.innerHTML = `❗ Error`;
  186.         }
  187.     }
  188.     
  189.     // Appends the isOwned tag to an anchor link
  190.     function appendTags(a, game) {
  191.         const div = document.createElement("div");
  192.         div.style.display = "inline-block";
  193.         const span = document.createElement("span");
  194.         div.append(span);
  195.         span.style = "margin-left: 5px; background:rgb(230,230,230); padding: 2px; border-radius: 2px";
  196.         
  197.         if (game === null) {
  198.             span.innerHTML = `<span title="Status unknown. Try refreshing.">❓</span>`;
  199.         } else if (game.isOwned) {
  200.             span.innerHTML = `<span title="Game is already claimed on itch.io">✔️</span>`;
  201.         } else {
  202.             if (!game.isClaimable) {
  203.                 if (game.hasFreeDownload && !game.hasPurchase) {
  204.                     span.innerHTML = `<span title="Game is a free download but not claimable">🆓</span>`;
  205.                 } else if (game.price) {
  206.                     span.innerHTML = `<span title="🛒 Game costs ${game.price}">🛒</span>`;
  207.                 } else {
  208.                     span.innerHTML = `<span title="Status unknown">👽</span>`;
  209.                 }
  210.             } else {
  211.                 const origPrice = game.original_price ? ` 🛒 Original price: ${game.original_price} 💸 Current Price: ${game.price}` : '';
  212.                 span.innerHTML = `<span title="Game is claimable but you haven't claimed it.${origPrice}">❌</span>`;
  213.                 
  214.                 const claimBtn = document.createElement("span");
  215.                 claimBtn.style = `margin-left: 2px; padding: 2px; cursor:pointer; background:rgb(220,220,220); border-radius: 5px`;
  216.                 claimBtn.className = "ClaimButton";
  217.                 claimBtn.innerText = "🛄 Claim Game";
  218.                 claimBtn.onclick = function(event) { claimClicked(event.target, game); };
  219.                 span.after(claimBtn);
  220.             }
  221.         }
  222.         if (game.hasCommunityCopies) {
  223.             const communityTag = document.createElement("span");
  224.             communityTag.title = `This game has ${game.communityCopies} Community Copies availible.`;
  225.             communityTag.innerText = '👪';
  226.             span.append(communityTag);
  227.         }
  228.         if (game !== null && game.breadcrumbs) {
  229.             span.firstChild.title += ' ℹ️ ' + game.breadcrumbs;
  230.             if (!a.title)
  231.                 a.title = game.breadcrumbs;
  232.             const tags = {
  233.                 //"Games": { icon: '🎮', title: "Video game" },
  234.                 "Tools": { icon: '🛠️', title: "Tool" },
  235.                 "Game assets": { icon: '🗃️', title: "Game asset" },
  236.                 "Comics": { icon: '🗨️', title: "Comic" },
  237.                 "Books": { icon: '📘', title: "Book" },
  238.                 "Physical games": { icon: '📖', title: "Physical game" },
  239.                 "Soundtracks": { icon: '🎵', title: "Soundtrack" },
  240.                 "Game mods": { icon: '⚙️', title: "Game mod" },
  241.             }
  242.             const category = game.breadcrumbs.split("›")[0].trim();
  243.             if (Object.prototype.hasOwnProperty.call(tags, category)) {
  244.                 const tag = document.createElement("span");
  245.                 tag.title = tags[category].title;
  246.                 tag.innerText = tags[category].icon;
  247.                 span.append(tag);
  248.             }
  249.         }
  250.         
  251.         a.after(div);
  252.     }
  253.     
  254.     function addClickHandler(a) {
  255.         a.addEventListener('mouseup', event => {
  256.             deleteItchGameCache(event.target.href);
  257.         });
  258.     }
  259.  
  260.     // Handles an itch.io link on a page
  261.     async function handleLink(a) {
  262.         addClickHandler(a);
  263.         const game = await getItchGame(a.href);
  264.         appendTags(a, game);
  265.     }
  266.     
  267.     function isGameUrl(url) {
  268.         return /^https:\/\/[^.]+\.itch\.io\/[^/]+$/.test(url);
  269.     }
  270.     
  271.     // Finds all the itch.io links on the current page
  272.     function getItchLinks() {
  273.         let links = [...document.querySelectorAll("a[href*='itch.io/']")];
  274.         links = links.filter(a => isGameUrl(a.href));
  275.         links = links.filter(a => !a.classList.contains("return_link"));
  276.         links = links.filter(a => { const t = a.textContent.trim(); return t !== "" && t !== "GIF"; });
  277.         return links;
  278.     }
  279.     
  280.     function handlePage() {
  281.         if (isGameUrl(window.location.href)) {
  282.             // If we're on an Itch game page, update the cached details
  283.             const game = parsePage(window.location.href, document);
  284.             setItchGameCache(window.location.href, game);
  285.         }
  286.         // Try to find any itch links on the page and tag them
  287.         const as = getItchLinks();
  288.         as.forEach(handleLink);
  289.     }
  290.     
  291.     versionCacheInvalidator();
  292.     handlePage();
  293. })();