Twitch Custom Section Remover

Removes sections from Twitch.tv homepage based on user-defined strings in their rendered text. Gemini 2.5 Pro wrote the whole thing. Oneshot. No modifications. I'm unlikely to fix any issues.
安裝腳本 ?
發表問題、評論、或檢舉該腳本。
換行
// ==UserScript==
// @name         Twitch Custom Section Remover
// @namespace    http://tampermonkey.net/
// @version      1.0
// @description  Removes sections from Twitch.tv homepage based on user-defined strings in their rendered text. Gemini 2.5 Pro wrote the whole thing. Oneshot. No modifications. I'm unlikely to fix any issues.
// @author       SumOfAllN00bs
// @license      MIT
// @match        https://www.twitch.tv/*
// @grant        GM_getValue
// @grant        GM_setValue
// @grant        GM_addStyle
// @grant        GM_registerMenuCommand
// @run-at       document-idle
// ==/UserScript==

(function() {
    'use strict';

    const SCRIPT_PREFIX = 'TwitchSectionRemover';

    // --- Configuration ---
    // Load blocked strings from storage, with a default example.
    let blockedStrings = GM_getValue('twitchBlockedStrings', ['Streamer University']);

    // --- Styling for Hidden Sections ---
    // This class will be added to sections that should be hidden.
    GM_addStyle(`
        .gm-hidden-section {
            display: none !important;
            visibility: hidden !important;
            height: 0 !important;
            width: 0 !important;
            overflow: hidden !important;
            margin: 0 !important;
            padding: 0 !important;
            border: none !important;
        }
    `);

    // --- Functions to Manage Blocked Strings (via Tampermonkey Menu) ---
    function listBlockedStrings() {
        const currentList = GM_getValue('twitchBlockedStrings', []);
        console.log(`${SCRIPT_PREFIX}: Currently blocked strings:`, currentList);
        alert(`${SCRIPT_PREFIX}: Currently blocked strings:\n${currentList.join('\n') || '(No strings blocked)'}`);
    }

    function addBlockedString() {
        const newString = prompt(`${SCRIPT_PREFIX}: Enter a string to block (case-sensitive):`);
        if (newString && newString.trim() !== '') {
            let currentBlockedStrings = GM_getValue('twitchBlockedStrings', []);
            if (!currentBlockedStrings.includes(newString.trim())) {
                currentBlockedStrings.push(newString.trim());
                GM_setValue('twitchBlockedStrings', currentBlockedStrings);
                blockedStrings = currentBlockedStrings; // Update local cache
                console.log(`${SCRIPT_PREFIX}: Added '${newString.trim()}'. New list:`, currentBlockedStrings);
                alert(`${SCRIPT_PREFIX}: Added '${newString.trim()}'.`);
                checkAndRemoveSections(); // Re-run to apply the new string immediately
            } else {
                alert(`${SCRIPT_PREFIX}: String '${newString.trim()}' is already in the list.`);
            }
        }
    }

    function removeBlockedString() {
        let currentBlockedStrings = GM_getValue('twitchBlockedStrings', []);
        if (currentBlockedStrings.length === 0) {
            alert(`${SCRIPT_PREFIX}: Blocklist is currently empty.`);
            return;
        }
        const stringToRemove = prompt(`${SCRIPT_PREFIX}: Enter the exact string to remove from the blocklist:\n\nCurrently blocked:\n${currentBlockedStrings.join('\n')}`);
        if (stringToRemove && stringToRemove.trim() !== '') {
            const index = currentBlockedStrings.indexOf(stringToRemove.trim());
            if (index > -1) {
                const removed = currentBlockedStrings.splice(index, 1);
                GM_setValue('twitchBlockedStrings', currentBlockedStrings);
                blockedStrings = currentBlockedStrings; // Update local cache
                console.log(`${SCRIPT_PREFIX}: Removed '${removed[0]}'. New list:`, currentBlockedStrings);
                alert(`${SCRIPT_PREFIX}: Removed '${removed[0]}'.`);
                // Re-evaluate all sections: those that were hidden ONLY by the removed string will now be unhidden.
                checkAndRemoveSections();
            } else {
                alert(`${SCRIPT_PREFIX}: String '${stringToRemove.trim()}' not found in the list.`);
            }
        }
    }

    // Register menu commands for Tampermonkey
    GM_registerMenuCommand("List Blocked Strings", listBlockedStrings);
    GM_registerMenuCommand("Add String to Blocklist", addBlockedString);
    GM_registerMenuCommand("Remove String from Blocklist", removeBlockedString);

    // --- Core Logic to Find and Remove/Hide Elements ---
    function checkAndRemoveSections() {
        // Refresh blockedStrings from storage in case it was modified
        blockedStrings = GM_getValue('twitchBlockedStrings', []);

        // If no strings are blocked, ensure all sections previously hidden by this script are unhidden.
        if (blockedStrings.length === 0) {
            document.querySelectorAll('.gm-hidden-section').forEach(el => {
                el.classList.remove('gm-hidden-section');
            });
            return;
        }

        // Selector for the "great-grandparent" div.
        // Based on your input: "The parent of the parent of this div is this element: <div class="Layout-sc-1xcs6mc-0 cwJXDZ">"
        // This means `div.Layout-sc-1xcs6mc-0.cwJXDZ` is the great-grandparent of the text holder,
        // and the grandparent of the div-to-be-removed.
        const greatGrandParentSelector = 'div.Layout-sc-1xcs6mc-0.cwJXDZ';
        const greatGrandParents = document.querySelectorAll(greatGrandParentSelector);

        greatGrandParents.forEach(ggpElement => {
            // Iterate through children of ggpElement (these are potential GrandParents of the target sections)
            Array.from(ggpElement.children).forEach(gpElement => {
                if (gpElement.nodeType !== Node.ELEMENT_NODE) return;

                // Iterate through children of gpElement (these are the "grand-child" divs, candidates for removal)
                Array.from(gpElement.children).forEach(gcDiv => {
                    if (gcDiv.nodeType !== Node.ELEMENT_NODE) return;

                    let sectionShouldBeHidden = false;

                    // Check this gcDiv and its descendants for any of the blocked strings.
                    // Query for elements that are likely to contain primary text/titles.
                    const elementsToCheckForText = [gcDiv, ...Array.from(gcDiv.querySelectorAll('h1, h2, h3, h4, h5, h6, p, a, span, div[class*="title"], div[data-a-target*="title"]'))];

                    for (const textHoldingElement of elementsToCheckForText) {
                        // Ensure the element is visible (not display:none via other means) unless we hid its parent (gcDiv).
                        // If gcDiv itself is hidden, its children won't have an offsetParent.
                        if (textHoldingElement.offsetParent === null && !gcDiv.classList.contains('gm-hidden-section')) {
                            continue;
                        }

                        // Get text from direct child text nodes of the current textHoldingElement.
                        // This adheres to "rendered text of the same element".
                        let currentElementOwnText = "";
                        for (const childNode of textHoldingElement.childNodes) {
                            if (childNode.nodeType === Node.TEXT_NODE) {
                                currentElementOwnText += childNode.textContent;
                            }
                        }
                        currentElementOwnText = currentElementOwnText.replace(/\s+/g, ' ').trim(); // Normalize whitespace

                        if (currentElementOwnText) {
                            for (const blockedStr of blockedStrings) {
                                if (currentElementOwnText.includes(blockedStr)) {
                                    sectionShouldBeHidden = true;
                                    // console.log(`${SCRIPT_PREFIX}: Matched "${blockedStr}" in text "${currentElementOwnText}" of element:`, textHoldingElement);
                                    break; // Found a match for this textHoldingElement
                                }
                            }
                        }
                        if (sectionShouldBeHidden) break; // No need to check more text elements if one match already decided to hide gcDiv
                    }

                    // Apply or remove the hidden class based on the check
                    if (sectionShouldBeHidden) {
                        if (!gcDiv.classList.contains('gm-hidden-section')) {
                            // console.log(`${SCRIPT_PREFIX}: Hiding section (gcDiv):`, gcDiv);
                            gcDiv.classList.add('gm-hidden-section');
                        }
                    } else {
                        // If it was previously hidden by this script but no longer matches any current blocked string
                        if (gcDiv.classList.contains('gm-hidden-section')) {
                            // console.log(`${SCRIPT_PREFIX}: Unhiding section (gcDiv) as it no longer matches:`, gcDiv);
                            gcDiv.classList.remove('gm-hidden-section');
                        }
                    }
                });
            });
        });
    }

    // --- Utility: Debounce Function ---
    // This prevents the checkAndRemoveSections function from running too frequently during rapid DOM changes.
    function debounce(func, wait) {
        let timeout;
        return function executedFunction(...args) {
            const context = this;
            const later = () => {
                timeout = null;
                func.apply(context, args);
            };
            clearTimeout(timeout);
            timeout = setTimeout(later, wait);
        };
    }

    // --- Mutation Observer ---
    // Observes changes in the DOM and triggers the removal logic.
    const debouncedSectionCheck = debounce(checkAndRemoveSections, 500); // 500ms debounce window
    const observer = new MutationObserver((mutationsList) => {
        for (const mutation of mutationsList) {
            // We are interested in changes to the child list (elements added/removed)
            // and subtree modifications.
            if (mutation.type === 'childList' && (mutation.addedNodes.length > 0 || mutation.removedNodes.length > 0)) {
                debouncedSectionCheck();
                return; // Debounced call will handle it
            }
            // if (mutation.type === 'subtree' ) { // Too frequent, childList is usually enough
            //    debouncedSectionCheck();
            //    return;
            // }
        }
    });

    // Start observing the entire document for changes.
    observer.observe(document.documentElement, {
        childList: true, // Observe direct children additions/removals
        subtree: true    // Observe all descendants as well
    });

    // --- Initial Execution ---
    // Run the check function a couple of times after the page initially loads,
    // as content might still be populating.
    setTimeout(checkAndRemoveSections, 1000); // After 1 second
    setTimeout(checkAndRemoveSections, 3000); // After 3 seconds for more dynamic content

})();
欢迎访问Greasy Fork镜像
