☰

Site Filter (Protocol-Independent)

Manage allowed sites dynamically and reference this in other scripts.

Versión del día 13/2/2025. Echa un vistazo a la versión más reciente.

Este script no debería instalarse directamente. Es una biblioteca que utilizan otros scripts mediante la meta-directiva de inclusión // @require https://update.greatest.deepsurf.us/scripts/526770/1536607/Site%20Filter%20%28Protocol-Independent%29.js 

  1. // ==UserScript==
  2. // @name         Site Filter (Protocol-Independent)
  3. // @namespace    http://tampermonkey.net/
  4. // @version      2.0
  5. // @description  Manage allowed sites dynamically and reference this in other scripts.
  6. // @author       blvdmd
  7. // @match        *://*/*
  8. // @grant        GM_getValue
  9. // @grant        GM_setValue
  10. // @grant        GM_registerMenuCommand
  11. // @grant        GM_download
  12. // @run-at       document-start
  13. // ==/UserScript==
  14.  
  15. (function () {
  16.     'use strict';
  17.  
  18.     // ✅ Wait for `SCRIPT_STORAGE_KEY` to be set
  19.     function waitForScriptStorageKey(maxWait = 1000) {
  20.         return new Promise(resolve => {
  21.             const startTime = Date.now();
  22.             const interval = setInterval(() => {
  23.                 if (typeof window.SCRIPT_STORAGE_KEY !== 'undefined') {
  24.                     clearInterval(interval);
  25.                     resolve(window.SCRIPT_STORAGE_KEY);
  26.                 } else if (Date.now() - startTime > maxWait) {
  27.                     clearInterval(interval);
  28.                     console.error("🚨 SCRIPT_STORAGE_KEY is not set! Make sure your script sets it **before** @require.");
  29.                     resolve(null);
  30.                 }
  31.             }, 50);
  32.         });
  33.     }
  34.  
  35.     (async function initialize() {
  36.  
  37.         async function waitForDocumentReady() {
  38.             if (document.readyState === "complete") return;
  39.             return new Promise(resolve => {
  40.                 window.addEventListener("load", resolve, { once: true });
  41.             });
  42.         }
  43.         // ✅ Wait for the script storage key
  44.         const key = await waitForScriptStorageKey();
  45.         if (!key) return;
  46.  
  47.         // ✅ Ensure the document is fully loaded before setting `shouldRunOnThisSite`
  48.         await waitForDocumentReady();
  49.  
  50.         const STORAGE_KEY = `additionalSites_${key}`; // Unique per script
  51.  
  52.         function getDefaultList() {
  53.             return [
  54.                 "*.example.*",
  55.                 "*example2*"
  56.             ];
  57.         }
  58.     
  59.         function normalizeUrl(url) {
  60.             return url.replace(/^https?:\/\//, ''); // Remove "http://" or "https://"
  61.         }
  62.     
  63.         // Load stored additional sites (default is an empty array)
  64.         let additionalSites = GM_getValue(STORAGE_KEY, []);
  65.     
  66.         // Merge user-defined sites with default sites (protocols ignored)
  67.         let mergedSites = [...new Set([...getDefaultList(), ...additionalSites])].map(normalizeUrl);
  68.     
  69.         GM_registerMenuCommand("➕ Add Current Site to Include List", addCurrentSiteMenu);
  70.         GM_registerMenuCommand("📜 View Included Sites", viewIncludedSites);
  71.         GM_registerMenuCommand("🗑️ Delete Specific Entries", deleteEntries);
  72.         GM_registerMenuCommand("✏️ Edit an Entry", editEntry);
  73.         GM_registerMenuCommand("🚨 Clear All Entries", clearAllEntries);
  74.         GM_registerMenuCommand("📤 Export Site List as JSON", exportAdditionalSites);
  75.         GM_registerMenuCommand("📥 Import Site List from JSON", importAdditionalSites);
  76.     
  77.         async function shouldRunOnThisSite() {
  78.             const currentFullPath = normalizeUrl(`${window.location.href}`);
  79.             return mergedSites.some(pattern => wildcardToRegex(normalizeUrl(pattern)).test(currentFullPath));
  80.         }
  81.     
  82.         // function wildcardToRegex(pattern) {
  83.         //     return new RegExp("^" + pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*').replace(/\?/g, '.') + "$");
  84.         // }
  85.     
  86.         /**
  87.          * Convert a wildcard pattern (e.g., "*.example.com/index.php?/forums/*") into a valid regex.
  88.          * - `*` → Matches any characters (`.*`)
  89.          * - `?` → Treated as a **literal question mark** (`\?`)
  90.          * - `.` → Treated as a **literal dot** (`\.`)
  91.          */
  92.         function wildcardToRegex(pattern) {
  93.             return new RegExp("^" + pattern
  94.                 .replace(/[-[\]{}()+^$|#\s]/g, '\\$&') // Escape regex special characters (EXCEPT `.` and `?`)
  95.                 .replace(/\./g, '\\.') // Ensure `.` is treated as a literal dot
  96.                 .replace(/\?/g, '\\?') // Ensure `?` is treated as a literal question mark
  97.                 .replace(/\*/g, '.*') // Convert `*` to `.*` (match any sequence)
  98.             + "$");
  99.         }
  100.     
  101.     
  102.         function addCurrentSiteMenu() {
  103.             const currentHost = window.location.hostname;
  104.             const currentPath = window.location.pathname;
  105.             const domainParts = currentHost.split('.');
  106.             const baseDomain = domainParts.length > 2 ? domainParts.slice(-2).join('.') : domainParts.join('.');
  107.             const secondLevelDomain = domainParts.length > 2 ? domainParts.slice(-2, -1)[0] : domainParts[0];
  108.     
  109.             const options = [
  110.                 { name: `Preferred Domain Match (*${secondLevelDomain}.*)`, pattern: `*${secondLevelDomain}.*` },
  111.                 { name: `Base Hostname (*.${baseDomain}*)`, pattern: `*.${baseDomain}*` },
  112.                 { name: `Base Domain (*.${secondLevelDomain}.*)`, pattern: `*.${secondLevelDomain}.*` },
  113.                 { name: `Host Contains (*${secondLevelDomain}*)`, pattern: `*${secondLevelDomain}*` },
  114.                 { name: `Exact Path (${currentHost}${currentPath})`, pattern: normalizeUrl(`${window.location.href}`) },
  115.                 { name: "Custom Wildcard Pattern", pattern: normalizeUrl(`${window.location.href}`) }
  116.             ];
  117.     
  118.             const userChoice = prompt(
  119.                 "Select an option to add the site:\n" +
  120.                 options.map((opt, index) => `${index + 1}. ${opt.name}`).join("\n") +
  121.                 "\nEnter a number or cancel."
  122.             );
  123.     
  124.             if (!userChoice) return;
  125.             const selectedIndex = parseInt(userChoice, 10) - 1;
  126.             if (selectedIndex >= 0 && selectedIndex < options.length) {
  127.                 let pattern = normalizeUrl(options[selectedIndex].pattern);
  128.                 if (options[selectedIndex].name === "Custom Wildcard Pattern") {
  129.                     pattern = normalizeUrl(prompt("Edit custom wildcard pattern:", pattern));
  130.                     if (!pattern.trim()) return alert("Invalid pattern. Operation canceled.");
  131.                 }
  132.                 if (!additionalSites.includes(pattern)) {
  133.                     additionalSites.push(pattern);
  134.                     GM_setValue(STORAGE_KEY, additionalSites);
  135.                     mergedSites = [...new Set([...getDefaultList(), ...additionalSites])].map(normalizeUrl);
  136.                     alert(`✅ Added site with pattern: ${pattern}`);
  137.                 } else {
  138.                     alert(`⚠️ Pattern "${pattern}" is already in the list.`);
  139.                 }
  140.             }
  141.         }
  142.     
  143.         function viewIncludedSites() {
  144.             //alert(`🔍 Included Sites:\n${mergedSites.join("\n") || "No sites added yet."}`);
  145.             alert(`🔍 Included Sites:\n${additionalSites.join("\n") || "No sites added yet."}`);
  146.         }
  147.     
  148.         function deleteEntries() {
  149.             if (additionalSites.length === 0) return alert("⚠️ No user-defined entries to delete.");
  150.             const userChoice = prompt("Select entries to delete (comma-separated numbers):\n" +
  151.                 additionalSites.map((item, index) => `${index + 1}. ${item}`).join("\n"));
  152.             if (!userChoice) return;
  153.             const indicesToRemove = userChoice.split(',').map(num => parseInt(num.trim(), 10) - 1);
  154.             additionalSites = additionalSites.filter((_, index) => !indicesToRemove.includes(index));
  155.             GM_setValue(STORAGE_KEY, additionalSites);
  156.             mergedSites = [...new Set([...getDefaultList(), ...additionalSites])].map(normalizeUrl);
  157.             alert("✅ Selected entries have been deleted.");
  158.         }
  159.     
  160.         function editEntry() {
  161.             if (additionalSites.length === 0) return alert("⚠️ No user-defined entries to edit.");
  162.             const userChoice = prompt("Select an entry to edit:\n" +
  163.                 additionalSites.map((item, index) => `${index + 1}. ${item}`).join("\n"));
  164.             if (!userChoice) return;
  165.             const selectedIndex = parseInt(userChoice, 10) - 1;
  166.             if (selectedIndex < 0 || selectedIndex >= additionalSites.length) return alert("❌ Invalid selection.");
  167.             const newPattern = normalizeUrl(prompt("Edit the pattern:", additionalSites[selectedIndex]));
  168.             if (newPattern && newPattern.trim() && newPattern !== additionalSites[selectedIndex]) {
  169.                 additionalSites[selectedIndex] = newPattern.trim();
  170.                 GM_setValue(STORAGE_KEY, additionalSites);
  171.                 mergedSites = [...new Set([...getDefaultList(), ...additionalSites])].map(normalizeUrl);
  172.                 alert("✅ Entry updated.");
  173.             }
  174.         }
  175.     
  176.         function clearAllEntries() {
  177.             if (additionalSites.length === 0) return alert("⚠️ No user-defined entries to clear.");
  178.             if (confirm(`🚨 You have ${additionalSites.length} entries. Clear all?`)) {
  179.                 additionalSites = [];
  180.                 GM_setValue(STORAGE_KEY, additionalSites);
  181.                 mergedSites = [...getDefaultList()].map(normalizeUrl);
  182.                 alert("✅ All user-defined entries cleared.");
  183.             }
  184.         }
  185.     
  186.         function exportAdditionalSites() {
  187.             GM_download("data:text/json;charset=utf-8," + encodeURIComponent(JSON.stringify(additionalSites, null, 2)), "additionalSites_backup.json");
  188.             alert("📤 Additional sites exported as JSON.");
  189.         }
  190.     
  191.         function importAdditionalSites() {
  192.             const input = document.createElement("input");
  193.             input.type = "file";
  194.             input.accept = ".json";
  195.             input.onchange = event => {
  196.                 const reader = new FileReader();
  197.                 reader.onload = e => {
  198.                     additionalSites = JSON.parse(e.target.result);
  199.                     GM_setValue(STORAGE_KEY, additionalSites);
  200.                     mergedSites = [...new Set([...getDefaultList(), ...additionalSites])].map(normalizeUrl);
  201.                     alert("📥 Sites imported successfully.");
  202.                 };
  203.                 reader.readAsText(event.target.files[0]);
  204.             };
  205.             input.click();
  206.         }
  207.     
  208.         window.shouldRunOnThisSite = shouldRunOnThisSite;
  209.     })();
  210. })();