@sv443-network/userutils 2.0.1 → 4.0.0

package/dist/index.js

@@ -48,28 +48,36 @@ var __async = (__this, __arguments, generator) => {
 function clamp(value, min, max) {
   return Math.max(Math.min(value, max), min);
 }
-function mapRange(value, range_1_min, range_1_max, range_2_min, range_2_max) {
-  if (Number(range_1_min) === 0 && Number(range_2_min) === 0)
-    return value * (range_2_max / range_1_max);
-  return (value - range_1_min) * ((range_2_max - range_2_min) / (range_1_max - range_1_min)) + range_2_min;
+function mapRange(value, range1min, range1max, range2min, range2max) {
+  if (Number(range1min) === 0 && Number(range2min) === 0)
+    return value * (range2max / range1max);
+  return (value - range1min) * ((range2max - range2min) / (range1max - range1min)) + range2min;
 }
 function randRange(...args) {
   let min, max;
-  if (typeof args[0] === "number" && typeof args[1] === "number") {
+  if (typeof args[0] === "number" && typeof args[1] === "number")
     [min, max] = args;
-  } else if (typeof args[0] === "number" && typeof args[1] !== "number") {
+  else if (typeof args[0] === "number" && typeof args[1] !== "number") {
     min = 0;
-    max = args[0];
+    [max] = args;
   } else
     throw new TypeError(`Wrong parameter(s) provided - expected: "number" and "number|undefined", got: "${typeof args[0]}" and "${typeof args[1]}"`);
   min = Number(min);
   max = Number(max);
   if (isNaN(min) || isNaN(max))
-    throw new TypeError(`Parameters "min" and "max" can't be NaN`);
+    return NaN;
   if (min > max)
     throw new TypeError(`Parameter "min" can't be bigger than "max"`);
   return Math.floor(Math.random() * (max - min + 1)) + min;
 }
+function randomId(length = 16, radix = 16) {
+  const arr = new Uint8Array(length);
+  crypto.getRandomValues(arr);
+  return Array.from(
+    arr,
+    (v) => mapRange(v, 0, 255, 0, radix).toString(radix).substring(0, 1)
+  ).join("");
+}
 
 // lib/array.ts
 function randomItem(array) {
@@ -99,14 +107,14 @@ function randomizeArray(array) {
   return retArray;
 }
 
-// lib/config.ts
+// lib/ConfigManager.ts
 var ConfigManager = class {
   /**
    * Creates an instance of ConfigManager to manage a user configuration that is cached in memory and persistently saved across sessions.  
    * Supports migrating data from older versions of the configuration to newer ones and populating the cache with default data if no persistent data is found.  
    *   
    * ⚠️ Requires the directives `@grant GM.getValue` and `@grant GM.setValue`  
-   * ⚠️ Make sure to call `loadData()` at least once after creating an instance, or the returned data will be the same as `options.defaultConfig`
+   * ⚠️ Make sure to call {@linkcode loadData()} at least once after creating an instance, or the returned data will be the same as `options.defaultConfig`
    * 
    * @template TData The type of the data that is saved in persistent storage (will be automatically inferred from `config.defaultConfig`) - this should also be the type of the data format associated with the current `options.formatVersion`
    * @param options The options for this ConfigManager instance
@@ -149,7 +157,10 @@ var ConfigManager = class {
       }
     });
   }
-  /** Returns a copy of the data from the in-memory cache. Use `loadData()` to get fresh data from persistent storage (usually not necessary since the cache should always exactly reflect persistent storage). */
+  /**
+   * Returns a copy of the data from the in-memory cache.  
+   * Use {@linkcode loadData()} to get fresh data from persistent storage (usually not necessary since the cache should always exactly reflect persistent storage).
+   */
   getData() {
     return this.deepCopy(this.cachedConfig);
   }
@@ -179,8 +190,8 @@ var ConfigManager = class {
   }
   /**
    * Call this method to clear all persistently stored data associated with this ConfigManager instance.  
-   * The in-memory cache will be left untouched, so you may still access the data with `getData()`.  
-   * Calling `loadData()` or `setData()` after this method was called will recreate persistent storage with the cached or default data.  
+   * The in-memory cache will be left untouched, so you may still access the data with {@linkcode getData()}  
+   * Calling {@linkcode loadData()} or {@linkcode setData()} after this method was called will recreate persistent storage with the cached or default data.  
    *   
    * ⚠️ This requires the additional directive `@grant GM.deleteValue`
    */
@@ -273,7 +284,7 @@ function openInNewTab(href) {
   openElem.click();
   setTimeout(openElem.remove, 50);
 }
-function interceptEvent(eventObject, eventName, predicate) {
+function interceptEvent(eventObject, eventName, predicate = () => true) {
   if (typeof Error.stackTraceLimit === "number" && Error.stackTraceLimit < 1e3) {
     Error.stackTraceLimit = 1e3;
   }
@@ -291,56 +302,9 @@ function interceptEvent(eventObject, eventName, predicate) {
     };
   })(eventObject.__proto__.addEventListener);
 }
-function interceptWindowEvent(eventName, predicate) {
+function interceptWindowEvent(eventName, predicate = () => true) {
   return interceptEvent(getUnsafeWindow(), eventName, predicate);
 }
-function amplifyMedia(mediaElement, initialMultiplier = 1) {
-  const context = new (window.AudioContext || window.webkitAudioContext)();
-  const props = {
-    /** Sets the gain multiplier */
-    setGain(multiplier) {
-      props.gainNode.gain.setValueAtTime(multiplier, props.context.currentTime);
-    },
-    /** Returns the current gain multiplier */
-    getGain() {
-      return props.gainNode.gain.value;
-    },
-    /** Enable the amplification for the first time or if it was disabled before */
-    enable() {
-      props.source.connect(props.limiterNode);
-      props.limiterNode.connect(props.gainNode);
-      props.gainNode.connect(props.context.destination);
-    },
-    /** Disable the amplification */
-    disable() {
-      props.source.disconnect(props.limiterNode);
-      props.limiterNode.disconnect(props.gainNode);
-      props.gainNode.disconnect(props.context.destination);
-      props.source.connect(props.context.destination);
-    },
-    /**
-     * Set the options of the [limiter / DynamicsCompressorNode](https://developer.mozilla.org/en-US/docs/Web/API/DynamicsCompressorNode/DynamicsCompressorNode#options)  
-     * The default is `{ threshold: -12, knee: 30, ratio: 12, attack: 0.003, release: 0.25 }`
-     */
-    setLimiterOptions(options) {
-      for (const [key, val] of Object.entries(options))
-        props.limiterNode[key].setValueAtTime(val, props.context.currentTime);
-    },
-    context,
-    source: context.createMediaElementSource(mediaElement),
-    gainNode: context.createGain(),
-    limiterNode: context.createDynamicsCompressor()
-  };
-  props.setLimiterOptions({
-    threshold: -12,
-    knee: 30,
-    ratio: 12,
-    attack: 3e-3,
-    release: 0.25
-  });
-  props.setGain(initialMultiplier);
-  return props;
-}
 function isScrollable(element) {
   const { overflowX, overflowY } = getComputedStyle(element);
   return {
@@ -379,63 +343,184 @@ function fetchAdvanced(_0) {
     return res;
   });
 }
-function insertValues(str, ...values) {
-  return str.replace(/%\d/gm, (match) => {
+function insertValues(input, ...values) {
+  return input.replace(/%\d/gm, (match) => {
     var _a, _b;
     const argIndex = Number(match.substring(1)) - 1;
     return (_b = (_a = values[argIndex]) != null ? _a : match) == null ? void 0 : _b.toString();
   });
 }
-
-// lib/onSelector.ts
-var selectorMap = /* @__PURE__ */ new Map();
-function onSelector(selector, options) {
-  let selectorMapItems = [];
-  if (selectorMap.has(selector))
-    selectorMapItems = selectorMap.get(selector);
-  selectorMapItems.push(options);
-  selectorMap.set(selector, selectorMapItems);
-  checkSelectorExists(selector, selectorMapItems);
+function compress(input, compressionFormat, outputType = "base64") {
+  return __async(this, null, function* () {
+    const byteArray = typeof input === "string" ? new TextEncoder().encode(input) : input;
+    const comp = new CompressionStream(compressionFormat);
+    const writer = comp.writable.getWriter();
+    writer.write(byteArray);
+    writer.close();
+    const buf = yield new Response(comp.readable).arrayBuffer();
+    return outputType === "arrayBuffer" ? buf : ab2str(buf);
+  });
+}
+function decompress(input, compressionFormat, outputType = "string") {
+  return __async(this, null, function* () {
+    const byteArray = typeof input === "string" ? str2ab(input) : input;
+    const decomp = new DecompressionStream(compressionFormat);
+    const writer = decomp.writable.getWriter();
+    writer.write(byteArray);
+    writer.close();
+    const buf = yield new Response(decomp.readable).arrayBuffer();
+    return outputType === "arrayBuffer" ? buf : new TextDecoder().decode(buf);
+  });
+}
+function ab2str(buf) {
+  return getUnsafeWindow().btoa(
+    new Uint8Array(buf).reduce((data, byte) => data + String.fromCharCode(byte), "")
+  );
 }
-function removeOnSelector(selector) {
-  return selectorMap.delete(selector);
+function str2ab(str) {
+  return Uint8Array.from(getUnsafeWindow().atob(str), (c) => c.charCodeAt(0));
 }
-function checkSelectorExists(selector, options) {
-  const deleteIndices = [];
-  options.forEach((option, i) => {
-    try {
-      const elements = option.all ? document.querySelectorAll(selector) : document.querySelector(selector);
-      if (elements !== null && elements instanceof NodeList && elements.length > 0 || elements !== null) {
-        option.listener(elements);
-        if (!option.continuous)
-          deleteIndices.push(i);
+
+// lib/SelectorObserver.ts
+var SelectorObserver = class {
+  constructor(baseElement, options = {}) {
+    __publicField(this, "enabled", false);
+    __publicField(this, "baseElement");
+    __publicField(this, "observer");
+    __publicField(this, "observerOptions");
+    __publicField(this, "listenerMap");
+    this.baseElement = baseElement;
+    this.listenerMap = /* @__PURE__ */ new Map();
+    this.observer = new MutationObserver(() => this.checkAllSelectors());
+    this.observerOptions = __spreadValues({
+      childList: true,
+      subtree: true
+    }, options);
+  }
+  checkAllSelectors() {
+    for (const [selector, listeners] of this.listenerMap.entries())
+      this.checkSelector(selector, listeners);
+  }
+  checkSelector(selector, listeners) {
+    var _a;
+    if (!this.enabled)
+      return;
+    const baseElement = typeof this.baseElement === "string" ? document.querySelector(this.baseElement) : this.baseElement;
+    if (!baseElement)
+      return;
+    const all = listeners.some((listener) => listener.all);
+    const one = listeners.some((listener) => !listener.all);
+    const allElements = all ? baseElement.querySelectorAll(selector) : null;
+    const oneElement = one ? baseElement.querySelector(selector) : null;
+    for (const options of listeners) {
+      if (options.all) {
+        if (allElements && allElements.length > 0) {
+          options.listener(allElements);
+          if (!options.continuous)
+            this.removeListener(selector, options);
+        }
+      } else {
+        if (oneElement) {
+          options.listener(oneElement);
+          if (!options.continuous)
+            this.removeListener(selector, options);
+        }
       }
-    } catch (err) {
-      console.error(`Couldn't call listener for selector '${selector}'`, err);
+      if (((_a = this.listenerMap.get(selector)) == null ? void 0 : _a.length) === 0)
+        this.listenerMap.delete(selector);
     }
-  });
-  if (deleteIndices.length > 0) {
-    const newOptsArray = options.filter((_, i) => !deleteIndices.includes(i));
-    if (newOptsArray.length === 0)
-      selectorMap.delete(selector);
-    else {
-      selectorMap.set(selector, newOptsArray);
+  }
+  debounce(func, time) {
+    let timeout;
+    return function(...args) {
+      clearTimeout(timeout);
+      timeout = setTimeout(() => func.apply(this, args), time);
+    };
+  }
+  /**
+   * Starts observing the children of the base element for changes to the given {@linkcode selector} according to the set {@linkcode options}
+   * @param selector The selector to observe
+   * @param options Options for the selector observation
+   * @param options.listener Gets called whenever the selector was found in the DOM
+   * @param [options.all] Whether to use `querySelectorAll()` instead - default is false
+   * @param [options.continuous] Whether to call the listener continuously instead of just once - default is false
+   * @param [options.debounce] Whether to debounce the listener to reduce calls to `querySelector` or `querySelectorAll` - set undefined or <=0 to disable (default)
+   */
+  addListener(selector, options) {
+    options = __spreadValues({ all: false, continuous: false, debounce: 0 }, options);
+    if (options.debounce && options.debounce > 0 || this.observerOptions.defaultDebounce && this.observerOptions.defaultDebounce > 0) {
+      options.listener = this.debounce(
+        options.listener,
+        options.debounce || this.observerOptions.defaultDebounce
+      );
     }
+    if (this.listenerMap.has(selector))
+      this.listenerMap.get(selector).push(options);
+    else
+      this.listenerMap.set(selector, [options]);
+    this.checkSelector(selector, [options]);
   }
-}
-function initOnSelector(options = {}) {
-  const observer = new MutationObserver(() => {
-    for (const [selector, options2] of selectorMap.entries())
-      checkSelectorExists(selector, options2);
-  });
-  observer.observe(document.body, __spreadValues({
-    subtree: true,
-    childList: true
-  }, options));
-}
-function getSelectorMap() {
-  return selectorMap;
-}
+  /** Disables the observation of the child elements */
+  disable() {
+    if (!this.enabled)
+      return;
+    this.enabled = false;
+    this.observer.disconnect();
+  }
+  /**
+   * Enables or reenables the observation of the child elements.
+   * @param immediatelyCheckSelectors Whether to immediately check if all previously registered selectors exist (default is true)
+   * @returns Returns true when the observation was enabled, false otherwise (e.g. when the base element wasn't found)
+   */
+  enable(immediatelyCheckSelectors = true) {
+    const baseElement = typeof this.baseElement === "string" ? document.querySelector(this.baseElement) : this.baseElement;
+    if (this.enabled || !baseElement)
+      return false;
+    this.enabled = true;
+    this.observer.observe(baseElement, this.observerOptions);
+    if (immediatelyCheckSelectors)
+      this.checkAllSelectors();
+    return true;
+  }
+  /** Returns whether the observation of the child elements is currently enabled */
+  isEnabled() {
+    return this.enabled;
+  }
+  /** Removes all listeners that have been registered with {@linkcode addListener()} */
+  clearListeners() {
+    this.listenerMap.clear();
+  }
+  /**
+   * Removes all listeners for the given {@linkcode selector} that have been registered with {@linkcode addListener()}
+   * @returns Returns true when all listeners for the associated selector were found and removed, false otherwise
+   */
+  removeAllListeners(selector) {
+    return this.listenerMap.delete(selector);
+  }
+  /**
+   * Removes a single listener for the given {@linkcode selector} and {@linkcode options} that has been registered with {@linkcode addListener()}
+   * @returns Returns true when the listener was found and removed, false otherwise
+   */
+  removeListener(selector, options) {
+    const listeners = this.listenerMap.get(selector);
+    if (!listeners)
+      return false;
+    const index = listeners.indexOf(options);
+    if (index > -1) {
+      listeners.splice(index, 1);
+      return true;
+    }
+    return false;
+  }
+  /** Returns all listeners that have been registered with {@linkcode addListener()} */
+  getAllListeners() {
+    return this.listenerMap;
+  }
+  /** Returns all listeners for the given {@linkcode selector} that have been registered with {@linkcode addListener()} */
+  getListeners(selector) {
+    return this.listenerMap.get(selector);
+  }
+};
 
 // lib/translation.ts
 var trans = {};
@@ -463,30 +548,29 @@ tr.getLanguage = () => {
 };
 
 exports.ConfigManager = ConfigManager;
+exports.SelectorObserver = SelectorObserver;
 exports.addGlobalStyle = addGlobalStyle;
 exports.addParent = addParent;
-exports.amplifyMedia = amplifyMedia;
 exports.autoPlural = autoPlural;
 exports.clamp = clamp;
+exports.compress = compress;
 exports.debounce = debounce;
+exports.decompress = decompress;
 exports.fetchAdvanced = fetchAdvanced;
-exports.getSelectorMap = getSelectorMap;
 exports.getUnsafeWindow = getUnsafeWindow;
-exports.initOnSelector = initOnSelector;
 exports.insertAfter = insertAfter;
 exports.insertValues = insertValues;
 exports.interceptEvent = interceptEvent;
 exports.interceptWindowEvent = interceptWindowEvent;
 exports.isScrollable = isScrollable;
 exports.mapRange = mapRange;
-exports.onSelector = onSelector;
 exports.openInNewTab = openInNewTab;
 exports.pauseFor = pauseFor;
 exports.preloadImages = preloadImages;
 exports.randRange = randRange;
+exports.randomId = randomId;
 exports.randomItem = randomItem;
 exports.randomItemIndex = randomItemIndex;
 exports.randomizeArray = randomizeArray;
-exports.removeOnSelector = removeOnSelector;
 exports.takeRandomItem = takeRandomItem;
 exports.tr = tr;