☰

GitHub Join Date

Displays user's join date/time/age.

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

  1. // ==UserScript==
  2. // @name         GitHub Join Date
  3. // @description  Displays user's join 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. // @run-at       document-idle
  15. // ==/UserScript==
  16.  
  17. (function() {
  18.     'use strict';
  19.  
  20.     const ELEMENT_ID = 'userscript-join-date-display';
  21.     const CACHE_KEY = 'githubUserJoinDatesCache_v1';
  22.     const GITHUB_API_BASE = 'https://api.github.com/users/';
  23.     const FALLBACK_API_BASE = 'https://api.codetabs.com/v1/proxy/?quest=https://api.github.com/users/';
  24.     
  25.     let isProcessing = false;
  26.     let observerDebounceTimeout = null;
  27.  
  28.     function readCache() {
  29.         try {
  30.             const cachedData = localStorage.getItem(CACHE_KEY);
  31.             return cachedData ? JSON.parse(cachedData) : {};
  32.         } catch (e) {
  33.             return {};
  34.         }
  35.     }
  36.  
  37.     function writeCache(cacheData) {
  38.         try {
  39.             localStorage.setItem(CACHE_KEY, JSON.stringify(cacheData));
  40.         } catch (e) {
  41.  
  42.         }
  43.     }
  44.  
  45.     function getRelativeTime(dateString) {
  46.         const joinDate = new Date(dateString); 
  47.         const now = new Date(); 
  48.         const diffInSeconds = Math.round((now - joinDate) / 1000); 
  49.         const minute = 60, hour = 3600, day = 86400, month = 2592000, year = 31536000; 
  50.         
  51.         if (diffInSeconds < minute) return `less than a minute ago`; 
  52.         if (diffInSeconds < hour) { 
  53.             const m = Math.floor(diffInSeconds / minute); 
  54.             return `${m} ${m === 1 ? 'minute' : 'minutes'} ago`; 
  55.         } 
  56.         if (diffInSeconds < day) { 
  57.             const h = Math.floor(diffInSeconds / hour); 
  58.             return `${h} ${h === 1 ? 'hour' : 'hours'} ago`; 
  59.         } 
  60.         if (diffInSeconds < month) { 
  61.             const d = Math.floor(diffInSeconds / day); 
  62.             return `${d} ${d === 1 ? 'day' : 'days'} ago`; 
  63.         } 
  64.         if (diffInSeconds < year) { 
  65.             const mo = Math.floor(diffInSeconds / month); 
  66.             return `${mo} ${mo === 1 ? 'month' : 'months'} ago`; 
  67.         } 
  68.         const y = Math.floor(diffInSeconds / year); 
  69.         return `${y} ${y === 1 ? 'year' : 'years'} ago`;
  70.     }
  71.  
  72.     function getAbbreviatedMonth(date) {
  73.         const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
  74.         return months[date.getMonth()];
  75.     }
  76.  
  77.     async function fetchFromGitHubApi(username) {
  78.         const apiUrl = `${GITHUB_API_BASE}${username}`;
  79.         
  80.         return new Promise((resolve) => {
  81.             GM_xmlhttpRequest({
  82.                 method: 'GET',
  83.                 url: apiUrl,
  84.                 headers: {
  85.                     'Accept': 'application/vnd.github.v3+json'
  86.                 },
  87.                 onload: function(response) {
  88.                     if (response.status === 200) {
  89.                         try {
  90.                             const userData = JSON.parse(response.responseText);
  91.                             const createdAt = userData.created_at;
  92.                             if (createdAt) {
  93.                                 resolve({ success: true, data: createdAt });
  94.                             } else {
  95.                                 resolve({ success: false, error: 'Missing creation date' });
  96.                             }
  97.                         } catch (e) {
  98.                             resolve({ success: false, error: 'JSON parse error' });
  99.                         }
  100.                     } else {
  101.                         resolve({ 
  102.                             success: false, 
  103.                             error: `Status ${response.status}`, 
  104.                             useProxy: response.status === 403 || response.status === 429
  105.                         });
  106.                     }
  107.                 },
  108.                 onerror: function() {
  109.                     resolve({ success: false, error: 'Network error', useProxy: true });
  110.                 },
  111.                 ontimeout: function() {
  112.                     resolve({ success: false, error: 'Timeout', useProxy: true });
  113.                 }
  114.             });
  115.         });
  116.     }
  117.  
  118.     async function fetchFromProxyApi(username) {
  119.         const apiUrl = `${FALLBACK_API_BASE}${username}`;
  120.         
  121.         return new Promise((resolve) => {
  122.             GM_xmlhttpRequest({
  123.                 method: 'GET',
  124.                 url: apiUrl,
  125.                 onload: function(response) {
  126.                     if (response.status >= 200 && response.status < 300) {
  127.                         try {
  128.                             const userData = JSON.parse(response.responseText);
  129.                             const createdAt = userData.created_at;
  130.                             if (createdAt) {
  131.                                 resolve({ success: true, data: createdAt });
  132.                             } else {
  133.                                 resolve({ success: false, error: 'Missing creation date' });
  134.                             }
  135.                         } catch (e) {
  136.                             resolve({ success: false, error: 'JSON parse error' });
  137.                         }
  138.                     } else {
  139.                         resolve({ success: false, error: `Status ${response.status}` });
  140.                     }
  141.                 },
  142.                 onerror: function() {
  143.                     resolve({ success: false, error: 'Network error' });
  144.                 },
  145.                 ontimeout: function() {
  146.                     resolve({ success: false, error: 'Timeout' });
  147.                 }
  148.             });
  149.         });
  150.     }
  151.  
  152.     async function getGitHubJoinDate(username) {
  153.         const directResult = await fetchFromGitHubApi(username);
  154.         
  155.         if (directResult.success) {
  156.             return directResult.data;
  157.         }
  158.         
  159.         if (directResult.useProxy) {
  160.             console.log('GitHub Join Date: Use Proxy');
  161.             const proxyResult = await fetchFromProxyApi(username);
  162.             
  163.             if (proxyResult.success) {
  164.                 return proxyResult.data;
  165.             }
  166.         }
  167.         
  168.         return null;
  169.     }
  170.  
  171.     function removeExistingElement() {
  172.         const existingElement = document.getElementById(ELEMENT_ID);
  173.         if (existingElement) {
  174.             existingElement.remove();
  175.         }
  176.     }
  177.  
  178.     async function addOrUpdateJoinDateElement() {
  179.         if (document.getElementById(ELEMENT_ID) && !isProcessing) { return; }
  180.         if (isProcessing) { return; }
  181.  
  182.         const pathParts = window.location.pathname.split('/').filter(part => part);
  183.         if (pathParts.length < 1 || pathParts.length > 2 || (pathParts.length === 2 && !['sponsors', 'followers', 'following'].includes(pathParts[1]))) {
  184.             removeExistingElement(); 
  185.             return;
  186.         }
  187.         
  188.         const usernameElement = document.querySelector('.p-nickname.vcard-username') || 
  189.                                document.querySelector('h1.h2.lh-condensed');
  190.         
  191.         if (!usernameElement) {
  192.             removeExistingElement();
  193.             return;
  194.         }
  195.         
  196.         const username = pathParts[0].toLowerCase();
  197.  
  198.         isProcessing = true;
  199.         let joinElement = document.getElementById(ELEMENT_ID);
  200.         let createdAtISO = null;
  201.         let fromCache = false;
  202.  
  203.         try {
  204.             const cache = readCache();
  205.             if (cache[username]) {
  206.                 createdAtISO = cache[username];
  207.                 fromCache = true;
  208.             }
  209.  
  210.             if (!joinElement) {
  211.                 joinElement = document.createElement('div');
  212.                 joinElement.id = ELEMENT_ID;
  213.                 joinElement.innerHTML = fromCache ? "..." : "Loading...";
  214.                 joinElement.style.color = 'var(--color-fg-muted)';
  215.                 joinElement.style.fontSize = '14px';
  216.                 joinElement.style.fontWeight = 'normal';
  217.                 
  218.                 if (usernameElement.classList.contains('h2')) {
  219.                     joinElement.style.marginTop = '0px';
  220.                     
  221.                     const colorFgMuted = usernameElement.nextElementSibling?.classList.contains('color-fg-muted') ? 
  222.                                          usernameElement.nextElementSibling : null;
  223.                     
  224.                     if (colorFgMuted) {
  225.                         const innerDiv = colorFgMuted.querySelector('div') || colorFgMuted;
  226.                         innerDiv.appendChild(joinElement);
  227.                     } else {
  228.                         usernameElement.insertAdjacentElement('afterend', joinElement);
  229.                     }
  230.                 } else {
  231.                     joinElement.style.marginTop = '8px';
  232.                     usernameElement.insertAdjacentElement('afterend', joinElement);
  233.                 }
  234.             }
  235.  
  236.             if (!fromCache) {
  237.                 createdAtISO = await getGitHubJoinDate(username);
  238.                 joinElement = document.getElementById(ELEMENT_ID);
  239.                 if (!joinElement) { return; }
  240.                 
  241.                 if (createdAtISO) {
  242.                     const currentCache = readCache();
  243.                     currentCache[username] = createdAtISO;
  244.                     writeCache(currentCache);
  245.                 } else {
  246.                     removeExistingElement(); 
  247.                     return;
  248.                 }
  249.             }
  250.  
  251.             if (createdAtISO && joinElement) {
  252.                 const joinDate = new Date(createdAtISO);
  253.                 const day = joinDate.getDate();
  254.                 const month = getAbbreviatedMonth(joinDate);
  255.                 const year = joinDate.getFullYear();
  256.                 const hours = joinDate.getHours().toString().padStart(2, '0');
  257.                 const minutes = joinDate.getMinutes().toString().padStart(2, '0');
  258.                 const formattedTime = `${hours}:${minutes}`;
  259.                 const relativeTimeString = getRelativeTime(createdAtISO);
  260.                 
  261.                 joinElement.innerHTML = `<strong>Joined</strong> <span style="font-weight: normal;">${day} ${month} ${year} - ${formattedTime} (${relativeTimeString})</span>`;
  262.             } else if (!createdAtISO && joinElement) {
  263.                 removeExistingElement();
  264.             }
  265.  
  266.         } catch (error) {
  267.             removeExistingElement();
  268.         } finally {
  269.             isProcessing = false;
  270.         }
  271.     }
  272.  
  273.     function handlePotentialPageChange() {
  274.         clearTimeout(observerDebounceTimeout);
  275.         observerDebounceTimeout = setTimeout(() => {
  276.             addOrUpdateJoinDateElement();
  277.         }, 600);
  278.     }
  279.  
  280.     addOrUpdateJoinDateElement();
  281.  
  282.     const observer = new MutationObserver((mutationsList) => {
  283.         let potentiallyRelevantChange = false;
  284.         for (const mutation of mutationsList) {
  285.             if (mutation.type === 'childList' && (mutation.addedNodes.length > 0 || mutation.removedNodes.length > 0)) {
  286.                 const targetNode = mutation.target;
  287.                 if (targetNode && (targetNode.matches?.('main, main *, .Layout-sidebar, .Layout-sidebar *, body'))) {
  288.                     let onlySelfChange = false;
  289.                     if ((mutation.addedNodes.length === 1 && mutation.addedNodes[0].id === ELEMENT_ID && mutation.removedNodes.length === 0) ||
  290.                         (mutation.removedNodes.length === 1 && mutation.removedNodes[0].id === ELEMENT_ID && mutation.addedNodes.length === 0)) {
  291.                         onlySelfChange = true;
  292.                     }
  293.                     if (!onlySelfChange) { 
  294.                         potentiallyRelevantChange = true; 
  295.                         break; 
  296.                     }
  297.                 }
  298.             }
  299.         }
  300.         if(potentiallyRelevantChange) { 
  301.             handlePotentialPageChange(); 
  302.         }
  303.     });
  304.     observer.observe(document.body, { childList: true, subtree: true });
  305.  
  306. })();