☰

URL Replacer/Redirector

Redirect specific sites by replacing part of the URL.

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

  1. // ==UserScript==
  2. // @name         URL Replacer/Redirector
  3. // @namespace    https://github.com/theborg3of5/Userscripts/
  4. // @version      2.0
  5. // @description  Redirect specific sites by replacing part of the URL.
  6. // @author       Gavin Borg
  7. // @require      https://openuserjs.org/src/libs/sizzle/GM_config.js
  8. // @match        https://greasyfork.org/en/scripts/403100-url-replacer-redirector
  9. // @grant        GM_registerMenuCommand
  10. // @grant        GM_getValue
  11. // @grant        GM_setValue
  12. // @grant        GM_deleteValue
  13. // @grant        GM.getValue
  14. // @grant        GM.setValue
  15. // ==/UserScript==
  16.  
  17. // Grant GM_*value for legacy Greasemonkey, GM.*value for Greasemonkey 4+
  18.  
  19. // Settings conversion should be removed after a while, including:
  20. //  - convertOldStyleSettings()
  21. //  - Grant for GM_deleteValue
  22.  
  23. // Our configuration instance - this loads/saves settings and handles the config popup.
  24. const Config = new GM_config();
  25.  
  26. (async function ()
  27. {
  28.     'use strict';
  29.  
  30.     // Find the site that we matched
  31.     const startURL = window.location.href;
  32.     const currentSite = getUserSiteForURL(startURL);
  33.     
  34.     // Add a menu item to the menu to launch the config
  35.     GM_registerMenuCommand('Configure redirect settings', () => Config.open());
  36.     
  37.     // Set up and load config
  38.     let configSettings = buildConfigSettings(currentSite);
  39.     await initConfigAsync(configSettings); // await because we need to read from the resulting (async-loaded) values
  40.  
  41.     // Convert old-style settings if we find them.
  42.     await convertOldStyleSettings(configSettings);
  43.     
  44.     // Get replacement settings for the current URL
  45.     const replaceSettings = getSettingsForSite(currentSite);
  46.     if (!replaceSettings)
  47.     {
  48.         return;
  49.     }
  50.  
  51.     // Build new URL
  52.     const newURL = transformURL(startURL, replaceSettings);
  53.     
  54.     // Redirect to the new URL
  55.     if (startURL === newURL)
  56.     { 
  57.         logToConsole("Current URL is same as redirection target: " + newURL);
  58.         return
  59.     }
  60.     window.location.replace(newURL);
  61. })();
  62.  
  63. // Get the site (entry from user includes/matches) that matches the current URL.
  64. function getUserSiteForURL(startURL)
  65. {
  66.     for (const site of getUserSites())
  67.     {
  68.         // Use a RegExp so we check case-insensitively
  69.         let siteRegex = "";
  70.         if (site.startsWith("/"))
  71.         {
  72.             siteRegex = new RegExp(site.slice(1, -1), "i"); // If the site starts with a /, treat it as a regex (but remove the leading/trailing /)
  73.         }
  74.         else
  75.         {
  76.             siteRegex = new RegExp(site.replace(/\*/g, "[^ ]*"), "i"); // Otherwise replace * wildcards with regex-style [^ ]* wildcards
  77.         }
  78.  
  79.         if (siteRegex.test(startURL)) {
  80.             return site; // First match always wins
  81.         }
  82.     }
  83. }
  84.  
  85. // We support both includes and matches, but only the user-overridden ones of each.
  86. function getUserSites()
  87. { 
  88.     return GM_info.script.options.override.use_matches.concat(GM_info.script.options.override.use_includes);
  89. }
  90.  
  91. // Perform the replacements specified by the given settings.
  92. function transformURL(startURL, siteSettings)
  93. {
  94.     const { prefix, suffix, targetStrings, replacementStrings } = siteSettings;
  95.  
  96.     // Transform the URL
  97.     let newURL = startURL;
  98.     for (let i = 0; i < targetStrings.length; i++)
  99.     {
  100.         let toReplace = prefix + targetStrings[i] + suffix;
  101.         const replaceWith = prefix + replacementStrings[i] + suffix;
  102.  
  103.         // Use a RegEx to allow case-insensitive matching
  104.         toReplace = new RegExp(escapeRegex(toReplace), "i"); // Escape any regex characters - we don't support actual regex matching.
  105.  
  106.         newURL = newURL.replace(toReplace, replaceWith);
  107.     }
  108.  
  109.     return newURL;
  110. }
  111.  
  112. // From https://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript/3561711#3561711
  113. function escapeRegex(string)
  114. {
  115.     return string.replace(/[-[\]{}()*+!<=:?.\/\\^$|#\s,]/g, '\\$&');
  116. }
  117.  
  118. // Log a message to the console with a prefix so we know it's from this script.
  119. function logToConsole(message)
  120. { 
  121.     console.log("URL Replacer/Redirector: " + message);
  122. }
  123.  
  124. //#region Config handling
  125. // Build the settings object for GM_config.init()
  126. function buildConfigSettings(currentSite)
  127. {
  128.     // Build fields for each site
  129.     const fields = buildSiteFields(currentSite);
  130.  
  131.     const styles = `
  132.         /* Float the target strings fields to the left so that they can line up with their corresponding replacements */
  133.         div[id*=${fieldTargetStrings("")}] {
  134.             float: left;
  135.         }
  136.  
  137.         /* We use one section sub-header on the current site to call it out. We're overriding the
  138.             default settings from the framework (which include the ID), so !important is needed for
  139.             most of these properties. */
  140.         .section_desc {
  141.             float: right !important;
  142.             background: #00FF00 !important;
  143.             color: black !important;
  144.             width: fit-content !important;
  145.             font-weight: bold !important;
  146.             padding: 4px !important;
  147.             margin: 0px auto !important;
  148.             border-top: none !important;
  149.             border-radius: 0px 0px 10px 10px !important;
  150.         }";
  151.     `.replaceAll("\n", ""); // This format is nicer to read but the newlines cause issues in the config framework, so remove them
  152.  
  153.     return {
  154.         id: "URLReplacerRedirectorConfig",
  155.         title: "URL Replacer/Redirector Config",
  156.         fields: fields,
  157.         css: styles,
  158.     };
  159. }
  160.  
  161. // Build the specific fields in the config
  162. function buildSiteFields(currentSite)
  163. {
  164.     let fields = {};
  165.     for (const site of getUserSites())
  166.     {
  167.         // Section headers are the site URL as the user entered them
  168.         const sectionName = [site];
  169.         if (currentSite === site)
  170.         {
  171.             sectionName.push("This site"); // If this is the matched site, add a subheader to call it out
  172.         }
  173.  
  174.         fields[fieldPrefix(site)] = {
  175.             section: sectionName, // Section definition just goes on the first field inside
  176.             type: "text",
  177.             label: "Prefix",
  178.             labelPos: "left",
  179.             size: 75,
  180.             title: "This string (if set) must appear directly before the target string in the URL.",
  181.         }
  182.         fields[fieldSuffix(site)] = {
  183.             type: "text",
  184.             label: "Suffix",
  185.             labelPos: "left",
  186.             size: 75,
  187.             title: "This string (if set) must appear directly after the target string in the URL.",
  188.         }
  189.         fields[fieldTargetStrings(site)] = {
  190.             type: "textarea",
  191.             label: "Targets",
  192.             labelPos: "above",
  193.             title: "Enter one target per line. Each target will be replaced by its corresponding replacement.",
  194.         }
  195.         fields[fieldReplacementStrings(site)] = {
  196.             type: "textarea",
  197.             label: "Replacements",
  198.             labelPos: "above",
  199.             title: "Enter one replacement per line. Each replacement with replace its corresponding target.",
  200.         }
  201.         fields[fieldClearSite(site)] = {
  202.             type: "button",
  203.             label: "Clear redirects for this site",
  204.             title: "Clear all fields for this site, removing all redirection.",
  205.             save: false, // Don't save this field, it's just a button
  206.             click: function (siteToClear)
  207.             {
  208.                 return () => {
  209.                     Config.set(fieldPrefix(siteToClear), "");
  210.                     Config.set(fieldSuffix(siteToClear), "");
  211.                     Config.set(fieldTargetStrings(siteToClear), "");
  212.                     Config.set(fieldReplacementStrings(siteToClear), "");
  213.                 }
  214.             }(site), // Immediately invoke this wrapper with the current site so the inner function can capture it
  215.         }
  216.     }
  217.  
  218.     return fields;
  219. }
  220.  
  221. // This is just a Promise wrapper for GM_config.init that allows us to await initialization.
  222. async function initConfigAsync(settings)
  223. {
  224.     return new Promise((resolve) =>
  225.     {
  226.         // Have the init event (which should fire once config is done loading) resolve the promise
  227.         settings["events"] = {init: resolve};
  228.  
  229.         Config.init(settings);
  230.     });
  231. }
  232.  
  233. // Get the settings for the given site.
  234. function getSettingsForSite(site)
  235. {
  236.     if (!site)
  237.     {
  238.         console.log("No matching site found for URL");
  239.         return null;
  240.     }
  241.  
  242.     // Retrieve and return the settings
  243.     return {
  244.         prefix:             Config.get(fieldPrefix(site)),
  245.         suffix:             Config.get(fieldSuffix(site)),
  246.         targetStrings:      Config.get(fieldTargetStrings(site)).split("\n"),
  247.         replacementStrings: Config.get(fieldReplacementStrings(site)).split("\n"),
  248.     }
  249. }
  250.  
  251. //#region Field name "constants" based on their corresponding sites
  252. // These are also the keys used with [GM_]Config.get/set.
  253. function fieldPrefix(site)
  254. {
  255.     return "Prefix_" + site;
  256. }
  257. function fieldSuffix(site)
  258. {
  259.     return "Suffix_" + site;
  260. }
  261. function fieldTargetStrings(site)
  262. {
  263.     return "TargetString_" + site;
  264. }
  265. function fieldReplacementStrings(site)
  266. {
  267.     return "ReplacementString_" + site;
  268. }
  269. function fieldClearSite(site)
  270. {
  271.     return "ClearSite_" + site;
  272. }
  273. //#endregion Field name "constants" based on their corresponding sites
  274. //#endregion Config handling
  275.  
  276. // Convert settings from the old style (simple GM_setValue/GM_getValue storage, 1 config for all
  277. //  sites) to the new style (GM_config, one set of settings per site).
  278. async function convertOldStyleSettings(gmConfigSettings)
  279. {
  280.     // Check the only really required setting (for the script to do anything)
  281.     const replaceAry = GM_getValue("replaceTheseStrings");
  282.     if (!replaceAry)
  283.     {
  284.         return; // No old settings to convert, done.
  285.     }
  286.     logToConsole("Old-style settings found");
  287.  
  288.     // Safety check: if we ALSO have new-style settings, leave it alone.
  289.     if (GM_getValue("URLReplacerRedirectorConfig"))
  290.     {
  291.         logToConsole("New-style settings already exist, not converting old settings.");
  292.         return;
  293.     }
  294.     
  295.     const replacePrefix = GM_getValue("replacePrefix");
  296.     const replaceSuffix = GM_getValue("replaceSuffix");
  297.     
  298.     // Old style: 1 config for ALL sites
  299.     // New style: 1 config PER site
  300.     // So, the conversion is just to copy the config onto each site.
  301.     logToConsole("Starting settings conversion...");
  302.     for (const site of getUserSites())
  303.     {
  304.         // Split replaceAry into targets (keys) and replacements (values)
  305.         let targetsAry = [];
  306.         let replacementsAry = [];
  307.         for (const target in replaceAry)
  308.         {
  309.             targetsAry.push(target);
  310.             replacementsAry.push(replaceAry[target]);
  311.         }
  312.  
  313.         Config.set(fieldPrefix(site), replacePrefix);
  314.         Config.set(fieldSuffix(site), replaceSuffix);
  315.         Config.set(fieldTargetStrings(site), targetsAry.join("\n"));
  316.         Config.set(fieldReplacementStrings(site), replacementsAry.join("\n"));
  317.     }
  318.  
  319.     // Save new settings
  320.     Config.save();
  321.     logToConsole("New-style settings saved.");
  322.     
  323.     // Remove the old-style settings so we don't do this again each time.
  324.     GM_deleteValue("replaceTheseStrings");
  325.     GM_deleteValue("replacePrefix");
  326.     GM_deleteValue("replaceSuffix");
  327.     logToConsole("Old-style settings removed.");
  328.     
  329.     logToConsole("Conversion complete.");
  330. }