☰

userscripts-core-library

Core library to be used on different userscripts

此脚本不应直接安装，它是一个供其他脚本使用的外部库。如果您需要使用该库，请在脚本元属性加入：// @require https://update.cn-greasyfork.org/scripts/476017/1357292/userscripts-core-library.js 

  1. // ==UserScript==
  2. // @name        userscripts-core-library
  3. // @version     0.3.0
  4. // @author      lucianjp
  5. // @description Core library to handle webpages dom with userscripts from document-start
  6. // ==/UserScript==
  7. // https://greasyfork.org/scripts/476017-userscripts-core-library/code/userscripts-core-library.js
  8.  
  9. //polyfills
  10. if (typeof GM == 'undefined') {
  11.   this.GM = {};
  12. }
  13.  
  14. class UserJsCore {
  15.   constructor() {
  16.     throw new Error('UserJsCore cannot be instantiated.');
  17.   }
  18.   
  19.   static ready = (callback) =>
  20.     document.readyState !== "loading"
  21.       ? callback()
  22.       : document.addEventListener("DOMContentLoaded", callback);
  23.  
  24.   static addStyle = (aCss) => {
  25.     let head = document.getElementsByTagName("head")[0];
  26.     if (!head) {
  27.       console.error("Head element not found. Cannot add style.");
  28.       return null;
  29.     }
  30.  
  31.     let style = document.createElement("style");
  32.     style.setAttribute("type", "text/css");
  33.     style.textContent = aCss;
  34.     head.appendChild(style);
  35.     return style;
  36.   };
  37.  
  38.   static observe = (observableCollection, continuous = false) => {
  39.     const observables = Array.from(observableCollection.entries()).filter(
  40.       ([_, observable]) => observable instanceof UserJsCore.ObservableAll || !observable.currentValue
  41.     );
  42.  
  43.     const observer = new MutationObserver(function (mutations) {
  44.       for (var i = mutations.length - 1; i >= 0; i--) {
  45.         const mutation = mutations[i];
  46.         const addedNodesLength = mutation.addedNodes.length;
  47.         if (addedNodesLength > 0) {
  48.           for (var j = addedNodesLength - 1; j >= 0; j--) {
  49.             const $node = mutation.addedNodes[j];
  50.             if ($node && $node.nodeType === 1) {
  51.               let observablesLength = observables.length;
  52.               for (let k = observablesLength - 1; k >= 0; k--) {
  53.                 const [_, observable] = observables[k];
  54.  
  55.                 if (observable.test($node)) {
  56.                   if(observable instanceof UserJsCore.Observable) {
  57.                     observable.set($node);
  58.                     const last = observables.pop();
  59.                     if (k < observablesLength - 1) observables[k] = last;
  60.                     observablesLength = observablesLength - 1;
  61.                   }
  62.                   if(observable instanceof UserJsCore.ObservableAll){
  63.                     observable.currentValue.includes($node) || observable.add($node);
  64.                   }
  65.                   break;
  66.                 }
  67.               }
  68.             }
  69.           }
  70.  
  71.           if (observables.length === 0 && !continuous) {
  72.             observer.disconnect();
  73.             return;
  74.           }
  75.         }
  76.       }
  77.     });
  78.  
  79.     observer.observe(document, { childList: true, subtree: true });
  80.  
  81.     if (!continuous) UserJsCore.ready(() => observer.disconnect());
  82.  
  83.     return observer;
  84.   };
  85.  
  86.   static Observable = class {
  87.     constructor(lookup, test) {
  88.       this.value = undefined;
  89.       this.callbacks = [];
  90.       this.lookup = lookup;
  91.       this.test = test;
  92.   
  93.       if (typeof lookup === "function") {
  94.         this.value = lookup();
  95.       }
  96.     }
  97.   
  98.     set(newValue) {
  99.       this.value = newValue;
  100.       this.executeCallbacks(this.value);
  101.     }
  102.   
  103.     then(callback) {
  104.       if (typeof callback === "function") {
  105.         this.callbacks.push(callback);
  106.         if (this.value) callback(this.value);
  107.       }
  108.       return this;
  109.     }
  110.   
  111.     executeCallbacks(value) {
  112.       this.callbacks.forEach((callback) => callback(value));
  113.     }
  114.   
  115.     get currentValue() {
  116.       return this.value;
  117.     }
  118.   };
  119.  
  120.   static ObservableAll = class {
  121.     constructor(lookup, test) {
  122.       this.values = [];
  123.       this.callbacks = [];
  124.       this.lookup = lookup;
  125.       this.test = test;
  126.   
  127.       if (typeof lookup === "function") {
  128.         this.values = [...lookup()];
  129.       }
  130.     }
  131.   
  132.     add(newValue) {
  133.       this.values.push(newValue);
  134.       this.executeCallbacks(newValue);
  135.     }
  136.   
  137.     then(callback) {
  138.       if (typeof callback === "function") {
  139.         this.callbacks.push(callback);
  140.         if (this.values.length > 0)
  141.           this.values.forEach((value) => callback(value));
  142.       }
  143.       return this;
  144.     }
  145.   
  146.     executeCallbacks(value) {
  147.       this.callbacks.forEach((callback) => callback(value));
  148.     }
  149.   
  150.     get currentValue() {
  151.       return this.values;
  152.     }
  153.   }
  154.   
  155.   static ObservableCollection = class extends Map {
  156.     constructor() {
  157.       super();
  158.     }
  159.   
  160.     add(name, observable) {
  161.       this.set(name, observable);
  162.       return observable;
  163.     }
  164.   }
  165.   
  166.   static Config = class {
  167.     static #config;
  168.     static #isInitializedPromise;
  169.   
  170.     constructor() {
  171.       throw new Error('Config cannot be instantiated.');
  172.     }
  173.   
  174.     static async init(defaultConfig = {}) {
  175.       if (!this.#isInitializedPromise) {
  176.         this.#isInitializedPromise = (async () => {
  177.           if (!this.#config) {
  178.             const storedConfig = await GM.getValue('config', {});
  179.             this.#config = { ...defaultConfig, ...storedConfig };
  180.           }
  181.         })();
  182.       }
  183.       await this.#isInitializedPromise;
  184.       return this; // Return the class instance after initialization
  185.     }
  186.   
  187.     static get(key) {
  188.       if (!this.#isInitializedPromise) {
  189.         throw new Error('Config has not been initialized. Call init() first.');
  190.       }
  191.       return this.#config[key];
  192.     }
  193.   
  194.     static set(key, value) {
  195.       if (!this.#isInitializedPromise) {
  196.         throw new Error('Config has not been initialized. Call init() first.');
  197.       }
  198.       this.#config[key] = value;
  199.       GM.setValue('config', this.#config);
  200.     }
  201.   }
  202.  
  203.   static Feature = class {
  204.     constructor(id, name, action) {
  205.       this._id = id;
  206.       this._name = name;
  207.       if (this.enabled == null) {
  208.         this.enabled = true;
  209.       }
  210.       if (this._enabled) {
  211.         try{
  212.           action();
  213.           console.groupCollapsed(name)
  214.           console.log(`${name} started`)
  215.         } catch (error){
  216.           console.group(name)
  217.           console.error(error);
  218.         }
  219.         console.groupEnd();
  220.       }
  221.     }
  222.     set id(id) {
  223.       this._id = id;
  224.     }
  225.     get id() {
  226.       return this._id;
  227.     }
  228.     set name(name) {
  229.       this._name = name;
  230.     }
  231.     get name() {
  232.       return this._name;
  233.     }
  234.     set enabled(enabled) {
  235.       this._enabled = enabled;
  236.       UserJsCore.Config.set(`feature_${this._id}`, this._enabled);
  237.     }
  238.     get enabled() {
  239.       return this._enabled || (this._enabled = UserJsCore.Config.get(`feature_${this._id}`));
  240.     }
  241.   
  242.     get displayName() {
  243.       return `${this._enabled ? "Disable" : "Enable"} ${this._name}`;
  244.     }
  245.   
  246.     toggle() {
  247.       this.enabled = !this.enabled;
  248.     }
  249.   }
  250.  
  251.   static Menu = class {
  252.     static #menuIds = [];
  253.     static #features;
  254.     static #notification;
  255.   
  256.     static initialize(features, notificationChange) {
  257.       if(GM.registerMenuCommand === undefined){
  258.         throw new Error("UserJsCore.Menu needs the GM.registerMenuCommand granted");
  259.       }
  260.       if(GM.unregisterMenuCommand === undefined){
  261.         throw new Error("UserJsCore.Menu needs the GM.unregisterMenuCommand granted");
  262.       }
  263.       this.#features = Object.values(features);
  264.       this.#notification = notificationChange;
  265.       this.#generateMenu();
  266.     }
  267.   
  268.     static #generateMenu() {
  269.       if (this.#menuIds.length > 0 && this.#notification) {
  270.         this.#notification();
  271.       }
  272.   
  273.       this.#menuIds.forEach((id) => GM.unregisterMenuCommand(id));
  274.       for (const feature of this.#features) {
  275.         this.#menuIds.push(
  276.           GM.registerMenuCommand(feature.displayName, () => {
  277.             feature.toggle();
  278.             this.#generateMenu();
  279.           })
  280.         );
  281.       }
  282.     }
  283.   }
  284.  
  285.   static AsyncQueue = class {
  286.     constructor(concurrentLimit = 6) {
  287.       this.concurrentLimit = concurrentLimit;
  288.       this.runningCount = 0;
  289.       this.queue = [];
  290.       this.isPaused = false;
  291.     }
  292.   
  293.     async enqueueAsync(func, priority = 0) {
  294.       return new Promise((resolve, reject) => {
  295.         const taskId = Symbol(); // Generate a unique ID for each task
  296.         const task = {
  297.           id: taskId,
  298.           func,
  299.           priority,
  300.           resolve,
  301.           reject,
  302.         };
  303.   
  304.         const execute = async (task) => {
  305.           if (this.isPaused) {
  306.             this.queue.unshift(task);
  307.             this.logQueueStatus();
  308.             return;
  309.           }
  310.   
  311.           this.runningCount++;
  312.           this.logQueueStatus();
  313.   
  314.           try {
  315.             const result = await task.func();
  316.             task.resolve(result);
  317.           } catch (error) {
  318.             task.reject(error);
  319.           } finally {
  320.             this.runningCount--;
  321.   
  322.             if (this.queue.length > 0) {
  323.               //this.queue.sort((a, b) => b.priority - a.priority);
  324.               const nextTask = this.queue.shift();
  325.               execute(nextTask);
  326.             }
  327.             this.logQueueStatus();
  328.           }
  329.         };
  330.   
  331.         this.logQueueStatus();
  332.   
  333.         if (this.runningCount < this.concurrentLimit) {
  334.           execute(task);
  335.         } else {
  336.           this.queue.push(task);
  337.           //this.queue.sort((a, b) => b.priority - a.priority);
  338.         }
  339.       });
  340.     }
  341.   
  342.     cancelTask(taskId) {
  343.       const index = this.queue.findIndex((task) => task.id === taskId);
  344.       if (index !== -1) {
  345.         const [canceledTask] = this.queue.splice(index, 1);
  346.         canceledTask.reject(new Error('Task canceled'));
  347.       }
  348.     }
  349.  
  350.     logQueueStatus() {
  351.       //console.log(`Running: ${this.runningCount}, Queued: ${this.queue.length}`);
  352.     }
  353.   
  354.     clearQueue() {
  355.       this.queue.forEach((task) => task.reject(new Error('Queue cleared')));
  356.       this.queue = [];
  357.     }
  358.   
  359.     pause() {
  360.       this.isPaused = true;
  361.       this.logQueueStatus();
  362.     }
  363.   
  364.     resume() {
  365.       this.isPaused = false;
  366.       if (this.queue.length > 0) {
  367.         this.queue.sort((a, b) => b.priority - a.priority);
  368.         const nextTask = this.queue.shift();
  369.         this.enqueueAsync(nextTask.func, nextTask.priority);
  370.       }
  371.       this.logQueueStatus();
  372.     }
  373.   }
  374.  
  375.   static Cache = class {
  376.     constructor(props = {}) {
  377.       this.version = props.version ?? 1;
  378.       this.name = props.dbName ?? window.location.origin;
  379.       this.storeName = props.storeName ?? 'cache';
  380.       this.db = null;
  381.       this.concurrentRequests = props.concurrentRequests ?? 6;
  382.  
  383.       this.queue = new UserJsCore.AsyncQueue(this.concurrentRequests);
  384.     }
  385.  
  386.     init() {
  387.       if(GM.xmlHttpRequest === undefined){
  388.         throw new Error("UserJsCore.Cache needs the GM.xmlHttpRequest granted");
  389.       }
  390.  
  391.       return new Promise(resolve => {
  392.         if(this.db) resolve(this);
  393.  
  394.         const request = indexedDB.open(this.name, this.version);
  395.   
  396.         request.onupgradeneeded = event => {
  397.           event.target.result.createObjectStore(this.storeName);
  398.         };
  399.   
  400.         request.onsuccess = () => {
  401.           this.db = request.result;
  402.   
  403.           this.db.onerror = () => {
  404.             console.error('Error creating/accessing db');
  405.           };
  406.   
  407.           if (this.db.setVersion && this.db.version !== this.version) {
  408.             const version = this.db.setVersion(this.version);
  409.             version.onsuccess = () => {
  410.               this.db.createObjectStore(this.storeName);
  411.               resolve(this);
  412.             };
  413.           } else {
  414.             resolve(this);
  415.           }
  416.         };
  417.       });
  418.     }
  419.   
  420.     putImage(key, url) {
  421.       return this.queue.enqueueAsync(async () => {
  422.         if (!this.db) {
  423.           throw new Error('DB not initialized. Call the init method');
  424.         }
  425.  
  426.         try {
  427.           const blob = await new Promise((resolve, reject) => {
  428.             console.log(`requesting : ${url}`)
  429.             GM.xmlHttpRequest({
  430.               method: 'GET',
  431.               url: url,
  432.               responseType: 'blob',
  433.               onload: (event) => resolve(event.response),
  434.               onerror: (e) => reject(e),
  435.             });
  436.           });
  437.   
  438.           // Check if the blob is a valid image
  439.           if (!(blob instanceof Blob) || blob.type.indexOf('image') === -1) {
  440.             throw new Error('The response does not contain a valid image.');
  441.           }
  442.   
  443.           const transaction = this.db.transaction(this.storeName, 'readwrite');
  444.           transaction.objectStore(this.storeName).put(blob, key);
  445.   
  446.           return URL.createObjectURL(blob);
  447.         } catch (error) {
  448.           console.error(error);
  449.           throw error;
  450.         }
  451.       });
  452.     }
  453.   
  454.     getImage(key) {
  455.       return new Promise((resolve, reject) => {
  456.         if (!this.db) {
  457.           return reject('DB not initialized. Call the init method');
  458.         }
  459.  
  460.         const transaction = this.db.transaction(this.storeName, 'readonly');
  461.         const request = transaction.objectStore(this.storeName).get(key);
  462.         request.onsuccess = event => {
  463.           const result = event?.target?.result;
  464.           if(result)
  465.             resolve(URL.createObjectURL(result));
  466.           else
  467.             resolve();
  468.         };
  469.  
  470.         request.onerror = (event) => {
  471.           const error = event?.target?.error;
  472.           reject(error);
  473.         };
  474.       });
  475.     }
  476.  
  477.     clear() {
  478.       return new Promise(resolve => {
  479.         if (!this.db)
  480.           return reject('DB not initialized. Call the init method');
  481.  
  482.         const transaction = this.db.transaction(this.storeName, "readwrite");
  483.         const request = transaction.objectStore(this.storeName).clear();
  484.         
  485.         request.onsuccess = () => {
  486.           resolve();
  487.         };
  488.       });
  489.     }
  490.   }
  491. };