☰

GitHub Repo Age

Displays repository creation date/time/age.

当前为 2025-05-11 提交的版本，查看 最新版本。

  1. // ==UserScript==
  2. // @name         GitHub Repo Age
  3. // @description  Displays repository creation date/time/age.
  4. // @icon         https://github.githubassets.com/favicons/favicon-dark.svg
  5. // @version      1.3
  6. // @author       afkarxyz
  7. // @namespace    https://github.com/afkarxyz/userscripts/
  8. // @supportURL   https://github.com/afkarxyz/userscripts/issues
  9. // @license      MIT
  10. // @match        https://github.com/*/*
  11. // @grant        GM_xmlhttpRequest
  12. // @connect      api.codetabs.com
  13. // @connect      api.github.com
  14. // ==/UserScript==
  15.  
  16. (function () {
  17.     'use strict';
  18.     const githubApiBase = 'https://api.github.com/repos/';
  19.     const fallbackApiBase = 'https://api.codetabs.com/v1/proxy/?quest=https://api.github.com/repos/';
  20.     const CACHE_KEY_PREFIX = 'github_repo_created_';
  21.  
  22.     const selectors = {
  23.         desktop: [
  24.             '.BorderGrid-cell .hide-sm.hide-md .f4.my-3',
  25.             '.BorderGrid-cell'
  26.         ],
  27.         mobile: [
  28.             '.d-block.d-md-none.mb-2.px-3.px-md-4.px-lg-5 .f4.mb-3.color-fg-muted',
  29.             '.d-block.d-md-none.mb-2.px-3.px-md-4.px-lg-5 .d-flex.gap-2.mt-n3.mb-3.flex-wrap',
  30.             '.d-block.d-md-none.mb-2.px-3.px-md-4.px-lg-5'
  31.         ]
  32.     };
  33.  
  34.     let currentRepoPath = '';
  35.  
  36.     function formatDate(isoDateStr) {
  37.         const createdDate = new Date(isoDateStr);
  38.         const now = new Date();
  39.         const diffTime = Math.abs(now - createdDate);
  40.  
  41.         const diffDays = Math.floor(diffTime / (1000 * 60 * 60 * 24));
  42.         const diffHours = Math.floor((diffTime % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60));
  43.         const diffMinutes = Math.floor((diffTime % (1000 * 60 * 60)) / (1000 * 60));
  44.  
  45.         const diffMonths = Math.floor(diffDays / 30.44);
  46.         const diffYears = Math.floor(diffMonths / 12);
  47.         const remainingMonths = diffMonths % 12;
  48.         const remainingDays = Math.floor(diffDays % 30.44);
  49.  
  50.         const datePart = createdDate.toLocaleDateString('en-GB', {
  51.             day: '2-digit',
  52.             month: 'short',
  53.             year: 'numeric'
  54.         });
  55.  
  56.         const timePart = createdDate.toLocaleTimeString('en-GB', {
  57.             hour: '2-digit',
  58.             minute: '2-digit',
  59.             hour12: false
  60.         });
  61.  
  62.         let ageText = '';
  63.  
  64.         if (diffYears > 0) {
  65.             ageText = `${diffYears} year${diffYears !== 1 ? 's' : ''}`;
  66.             if (remainingMonths > 0) {
  67.                 ageText += ` ${remainingMonths} month${remainingMonths !== 1 ? 's' : ''}`;
  68.             }
  69.         } else if (diffMonths > 0) {
  70.             ageText = `${diffMonths} month${diffMonths !== 1 ? 's' : ''}`;
  71.             if (remainingDays > 0) {
  72.                 ageText += ` ${remainingDays} day${remainingDays !== 1 ? 's' : ''}`;
  73.             }
  74.         } else if (diffDays > 0) {
  75.             ageText = `${diffDays} day${diffDays !== 1 ? 's' : ''}`;
  76.             if (diffHours > 0) {
  77.                 ageText += ` ${diffHours} hour${diffHours !== 1 ? 's' : ''}`;
  78.             }
  79.         } else if (diffHours > 0) {
  80.             ageText = `${diffHours} hour${diffHours !== 1 ? 's' : ''}`;
  81.             if (diffMinutes > 0) {
  82.                 ageText += ` ${diffMinutes} minute${diffMinutes !== 1 ? 's' : ''}`;
  83.             }
  84.         } else {
  85.             ageText = `${diffMinutes} minute${diffMinutes !== 1 ? 's' : ''}`;
  86.         }
  87.  
  88.         return `${datePart} - ${timePart} (${ageText} ago)`;
  89.     }
  90.  
  91.     const cache = {
  92.         getKey: function(user, repo) {
  93.             return `${CACHE_KEY_PREFIX}${user}_${repo}`;
  94.         },
  95.  
  96.         get: function(user, repo) {
  97.             try {
  98.                 const key = this.getKey(user, repo);
  99.                 const cachedValue = localStorage.getItem(key);
  100.                 if (!cachedValue) return null;
  101.                 return JSON.parse(cachedValue);
  102.             } catch (err) {
  103.                 return null;
  104.             }
  105.         },
  106.  
  107.         set: function(user, repo, value) {
  108.             try {
  109.                 const key = this.getKey(user, repo);
  110.                 localStorage.setItem(key, JSON.stringify(value));
  111.             } catch (err) {
  112.  
  113.             }
  114.         }
  115.     };
  116.  
  117.     async function fetchFromGitHubApi(user, repo) {
  118.         const apiUrl = `${githubApiBase}${user}/${repo}`;
  119.         
  120.         return new Promise((resolve) => {
  121.             GM_xmlhttpRequest({
  122.                 method: 'GET',
  123.                 url: apiUrl,
  124.                 headers: {
  125.                     'Accept': 'application/vnd.github.v3+json'
  126.                 },
  127.                 onload: function(response) {
  128.                     if (response.status === 200) {
  129.                         try {
  130.                             const data = JSON.parse(response.responseText);
  131.                             const createdAt = data.created_at;
  132.                             if (createdAt) {
  133.                                 resolve({ success: true, data: createdAt });
  134.                             } else {
  135.                                 resolve({ success: false, error: 'Missing creation date' });
  136.                             }
  137.                         } catch (e) {
  138.                             resolve({ success: false, error: 'JSON parse error' });
  139.                         }
  140.                     } else {
  141.                         resolve({ 
  142.                             success: false, 
  143.                             error: `Status ${response.status}`, 
  144.                             useProxy: response.status === 403 || response.status === 429
  145.                         });
  146.                     }
  147.                 },
  148.                 onerror: function() {
  149.                     resolve({ success: false, error: 'Network error', useProxy: true });
  150.                 },
  151.                 ontimeout: function() {
  152.                     resolve({ success: false, error: 'Timeout', useProxy: true });
  153.                 }
  154.             });
  155.         });
  156.     }
  157.  
  158.     async function fetchFromProxyApi(user, repo) {
  159.         const apiUrl = `${fallbackApiBase}${user}/${repo}`;
  160.         
  161.         return new Promise((resolve) => {
  162.             GM_xmlhttpRequest({
  163.                 method: 'GET',
  164.                 url: apiUrl,
  165.                 onload: function(response) {
  166.                     if (response.status >= 200 && response.status < 300) {
  167.                         try {
  168.                             const data = JSON.parse(response.responseText);
  169.                             const createdAt = data.created_at;
  170.                             if (createdAt) {
  171.                                 resolve({ success: true, data: createdAt });
  172.                             } else {
  173.                                 resolve({ success: false, error: 'Missing creation date' });
  174.                             }
  175.                         } catch (e) {
  176.                             resolve({ success: false, error: 'JSON parse error' });
  177.                         }
  178.                     } else {
  179.                         resolve({ success: false, error: `Status ${response.status}` });
  180.                     }
  181.                 },
  182.                 onerror: function() {
  183.                     resolve({ success: false, error: 'Network error' });
  184.                 },
  185.                 ontimeout: function() {
  186.                     resolve({ success: false, error: 'Timeout' });
  187.                 }
  188.             });
  189.         });
  190.     }
  191.  
  192.     async function getRepoCreationDate(user, repo) {
  193.         const cachedDate = cache.get(user, repo);
  194.         if (cachedDate) {
  195.             return cachedDate;
  196.         }
  197.  
  198.         const directResult = await fetchFromGitHubApi(user, repo);
  199.         
  200.         if (directResult.success) {
  201.             cache.set(user, repo, directResult.data);
  202.             return directResult.data;
  203.         }
  204.         
  205.         if (directResult.useProxy) {
  206.             console.log('GitHub Repo Age: Use Proxy');
  207.             const proxyResult = await fetchFromProxyApi(user, repo);
  208.             
  209.             if (proxyResult.success) {
  210.                 cache.set(user, repo, proxyResult.data);
  211.                 return proxyResult.data;
  212.             }
  213.         }
  214.         
  215.         return null;
  216.     }
  217.  
  218.     async function insertCreatedDate() {
  219.         const match = window.location.pathname.match(/^\/([^\/]+)\/([^\/]+)/);
  220.         if (!match) return false;
  221.  
  222.         const [_, user, repo] = match;
  223.         const repoPath = `${user}/${repo}`;
  224.  
  225.         currentRepoPath = repoPath;
  226.  
  227.         const createdAt = await getRepoCreationDate(user, repo);
  228.         if (!createdAt) return false;
  229.  
  230.         const formattedDate = formatDate(createdAt);
  231.         let insertedCount = 0;
  232.  
  233.         document.querySelectorAll('.repo-created-date').forEach(el => el.remove());
  234.  
  235.         for (const [view, selectorsList] of Object.entries(selectors)) {
  236.             for (const selector of selectorsList) {
  237.                 const element = document.querySelector(selector);
  238.                 if (element && !element.querySelector(`.repo-created-${view}`)) {
  239.                     insertDateElement(element, formattedDate, view);
  240.                     insertedCount++;
  241.                     break;
  242.                 }
  243.             }
  244.         }
  245.  
  246.         return insertedCount > 0;
  247.     }
  248.  
  249.     function insertDateElement(targetElement, formattedDate, view) {
  250.         const p = document.createElement('p');
  251.         p.className = `f6 color-fg-muted repo-created-date repo-created-${view}`;
  252.         p.style.marginTop = '4px';
  253.         p.style.marginBottom = '8px';
  254.         p.innerHTML = `<strong>Created</strong> ${formattedDate}`;
  255.  
  256.         if (view === 'mobile') {
  257.             const flexWrap = targetElement.querySelector('.flex-wrap');
  258.             if (flexWrap) {
  259.                 flexWrap.parentNode.insertBefore(p, flexWrap.nextSibling);
  260.                 return;
  261.             }
  262.  
  263.             const dFlex = targetElement.querySelector('.d-flex');
  264.             if (dFlex) {
  265.                 dFlex.parentNode.insertBefore(p, dFlex.nextSibling);
  266.                 return;
  267.             }
  268.         }
  269.  
  270.         targetElement.insertBefore(p, targetElement.firstChild);
  271.     }
  272.  
  273.     function checkAndInsertWithRetry(retryCount = 0, maxRetries = 5) {
  274.         insertCreatedDate().then(inserted => {
  275.             if (!inserted && retryCount < maxRetries) {
  276.                 const delay = Math.pow(2, retryCount) * 500;
  277.                 setTimeout(() => checkAndInsertWithRetry(retryCount + 1, maxRetries), delay);
  278.             }
  279.         });
  280.     }
  281.  
  282.     function checkForRepoChange() {
  283.         const match = window.location.pathname.match(/^\/([^\/]+)\/([^\/]+)/);
  284.         if (!match) return;
  285.  
  286.         const [_, user, repo] = match;
  287.         const repoPath = `${user}/${repo}`;
  288.  
  289.         if (repoPath !== currentRepoPath) {
  290.             checkAndInsertWithRetry();
  291.         }
  292.     }
  293.  
  294.     if (document.readyState === 'loading') {
  295.         document.addEventListener('DOMContentLoaded', () => checkAndInsertWithRetry());
  296.     } else {
  297.         checkAndInsertWithRetry();
  298.     }
  299.  
  300.     const originalPushState = history.pushState;
  301.     history.pushState = function() {
  302.         originalPushState.apply(this, arguments);
  303.         setTimeout(checkForRepoChange, 100);
  304.     };
  305.  
  306.     const originalReplaceState = history.replaceState;
  307.     history.replaceState = function() {
  308.         originalReplaceState.apply(this, arguments);
  309.         setTimeout(checkForRepoChange, 100);
  310.     };
  311.  
  312.     window.addEventListener('popstate', () => {
  313.         setTimeout(checkForRepoChange, 100);
  314.     });
  315.  
  316.     const observer = new MutationObserver((mutations) => {
  317.         for (const mutation of mutations) {
  318.             if (mutation.type === 'childList' &&
  319.                 (mutation.target.id === 'js-repo-pjax-container' ||
  320.                  mutation.target.id === 'repository-container-header')) {
  321.                 setTimeout(checkForRepoChange, 100);
  322.                 break;
  323.             }
  324.         }
  325.     });
  326.  
  327.     observer.observe(document.body, { childList: true, subtree: true });
  328. })();