billy-herrington-utils 1.6.0 → 2.0.1

package/src/utils/dom/index.ts

@@ -1,15 +1,31 @@
+import { sanitizeStr } from '../strings';
+import { waitForElementToAppear } from './observers';
+
+export {
+  waitForElementToAppear,
+  waitForElementToDisappear,
+  watchDomChangesWithThrottle,
+  watchElementChildrenCount,
+} from './observers';
+
+export function querySelectorText(el: HTMLElement, selector?: string): string {
+  if (!selector || typeof selector !== 'string') return '';
+  const text = el.querySelector<HTMLElement>(selector)?.innerText || '';
+  return sanitizeStr(text);
+}
+
 export function parseDom(html: string): HTMLElement {
   const parsed = new DOMParser().parseFromString(html, 'text/html').body;
-  return parsed.children.length > 1 ? parsed : parsed.firstElementChild as HTMLElement;
+  return parsed.children.length > 1 ? parsed : (parsed.firstElementChild as HTMLElement);
 }
 
-export function copyAttributes(target: HTMLElement | Element, source: HTMLElement | Element) {
+export function copyAttributes(target: HTMLElement, source: HTMLElement) {
   for (const attr of source.attributes) {
     attr.nodeValue && target.setAttribute(attr.nodeName, attr.nodeValue);
   }
 }
 
-export function replaceElementTag(e: HTMLElement | Element, tagName: string) {
+export function replaceElementTag(e: HTMLElement, tagName: string) {
   const newTagElement = document.createElement(tagName);
   copyAttributes(newTagElement, e);
   newTagElement.innerHTML = e.innerHTML;
@@ -17,74 +33,31 @@ export function replaceElementTag(e: HTMLElement | Element, tagName: string) {
   return newTagElement;
 }
 
-export function getAllUniqueParents(elements: HTMLCollection): Array<HTMLElement | Element> {
-  return Array.from(elements).reduce((acc, v) => {
-    if (v.parentElement && !acc.includes(v.parentElement as HTMLElement)) { acc.push(v.parentElement); }
-    return acc;
-  }, [] as Array<HTMLElement | Element>);
+export function getAllUniqueParents(
+  elements: HTMLCollection | HTMLElement[],
+): HTMLElement[] {
+  const parents = Array.from(elements)
+    .map((el) => el.parentElement)
+    .filter((parent): parent is HTMLElement => parent !== null);
+
+  return [...new Set(parents)];
 }
 
-export function findNextSibling(el: HTMLElement | Element) {
+export function findNextSibling(el: HTMLElement) {
   if (el.nextElementSibling) return el.nextElementSibling;
   if (el.parentElement) return findNextSibling(el.parentElement);
   return null;
 }
 
-export function waitForElementExists(parent: HTMLElement | Element, selector: string, callback: (el: Element) => void): void {
-  const observer = new MutationObserver((_mutations) => {
-    const el = parent.querySelector(selector);
-    if (el) {
-      observer.disconnect();
-      callback(el);
-    }
-  });
-  observer.observe(document.body, { childList: true, subtree: true });
-}
-
-export function watchElementChildrenCount(element: HTMLElement | Element,
-  callback: (observer: MutationObserver, count: number) => void): void {
-  let count = element.children.length;
-  const observer = new MutationObserver((mutationList, observer) => {
-    for (const mutation of mutationList) {
-      if (mutation.type === "childList") {
-        if (count !== element.children.length) {
-          count = element.children.length;
-          callback(observer, count);
-        }
-      }
-    }
-  });
-  observer.observe(element, { childList: true });
+export function exterminateVideo(video: HTMLVideoElement) {
+  video.removeAttribute('src');
+  video.load();
+  video.remove();
 }
 
-export function watchDomChangesWithThrottle(
-  element: HTMLElement | Element, 
-  callback: () => void,
-  throttle = 1000,
-  times = Infinity,
-  options: Record<string, boolean> = { childList: true, subtree: true, attributes: true }
+export function downloader(
+  options = { append: '', after: '', button: '', cbBefore: () => {} },
 ) {
-  let lastMutationTime: number;
-  let timeout: number;
-  let times_ = times;
-  const observer = new MutationObserver((_mutationList, _observer) => {
-    if (times_ !== Infinity && times_ < 1) {
-      observer.disconnect();
-      return;
-    }
-    times_--;
-    const now = Date.now();
-    if (lastMutationTime && now - lastMutationTime < throttle) {
-      timeout && clearTimeout(timeout);
-    }
-    timeout = setTimeout(callback, throttle);
-    lastMutationTime = now;
-  });
-  observer.observe(element, options);
-  return observer;
-}
-
-export function downloader(options = { append: "", after: "", button: "", cbBefore: () => { } }) {
   const btn = parseDom(options.button);
 
   if (options.append) document.querySelector(options.append)?.append(btn);
@@ -95,14 +68,8 @@ export function downloader(options = { append: "", after: "", button: "", cbBefo
 
     if (options.cbBefore) options.cbBefore();
 
-    waitForElementExists(document.body, 'video', (video: Element) => {
+    waitForElementToAppear(document.body, 'video', (video: Element) => {
       window.location.href = video.getAttribute('src') as string;
     });
   });
 }
-
-export function exterminateVideo(video: HTMLVideoElement) {
-  video.removeAttribute('src');
-  video.load();
-  video.remove();
-}

package/src/utils/dom/observers.ts

@@ -0,0 +1,76 @@
+export function waitForElementToAppear(
+  parent: HTMLElement,
+  selector: string,
+  callback: (el: Element) => void,
+) {
+  const observer = new MutationObserver((_mutations) => {
+    const el = parent.querySelector(selector);
+    if (el) {
+      observer.disconnect();
+      callback(el);
+    }
+  });
+
+  observer.observe(document.body, { childList: true, subtree: true });
+  return observer;
+}
+
+export function waitForElementToDisappear(observable: HTMLElement, callback: () => void) {
+  const observer = new MutationObserver((_mutations) => {
+    if (!observable.isConnected) {
+      observer.disconnect();
+      callback();
+    }
+  });
+
+  observer.observe(document.body, { childList: true, subtree: true });
+  return observer;
+}
+
+export function watchElementChildrenCount(
+  element: HTMLElement,
+  callback: (observer: MutationObserver, count: number) => void,
+) {
+  let count = element.children.length;
+  const observer = new MutationObserver((mutationList, observer) => {
+    for (const mutation of mutationList) {
+      if (mutation.type === 'childList') {
+        if (count !== element.children.length) {
+          count = element.children.length;
+          callback(observer, count);
+        }
+      }
+    }
+  });
+
+  observer.observe(element, { childList: true });
+  return observer;
+}
+
+export function watchDomChangesWithThrottle(
+  element: HTMLElement,
+  callback: () => void,
+  throttle = 1000,
+  times = Infinity,
+  options: MutationObserverInit = { childList: true, subtree: true, attributes: true },
+) {
+  let lastMutationTime: number;
+  let timeout: number;
+  let times_ = times;
+  const observer = new MutationObserver((_mutationList, _observer) => {
+    if (times_ !== Infinity && times_ < 1) {
+      observer.disconnect();
+      return;
+    }
+    times_--;
+    const now = Date.now();
+    if (lastMutationTime && now - lastMutationTime < throttle) {
+      timeout && clearTimeout(timeout);
+    }
+    timeout = setTimeout(callback, throttle);
+    lastMutationTime = now;
+  });
+
+  observer.observe(element, options);
+  return observer;
+}

package/src/utils/events/index.ts

@@ -1,4 +1,8 @@
-export function listenEvents(dom: HTMLElement | Element, events: Array<string>, callback: (e: Event) => void): void {
+export function listenEvents(
+  dom: HTMLElement,
+  events: Array<string>,
+  callback: (e: Event) => void,
+): void {
   for (const e of events) {
     dom.addEventListener(e, callback, true);
   }
@@ -8,7 +12,10 @@ export class Tick {
   private tick?: number;
   private callbackFinal?: () => void;
 
-  constructor(private delay: number, private startImmediate: boolean = true) {}
+  constructor(
+    private delay: number,
+    private startImmediate: boolean = true,
+  ) {}
 
   public start(callback: () => void, callbackFinal?: () => void): void {
     this.stop();

package/src/utils/fetch/index.ts

@@ -6,23 +6,30 @@ export const MOBILE_UA = [
   'Chrome/114.0.0.0 Mobile Safari/537.36',
 ].join(' ');
 
-export function fetchWith(
+export async function fetchWith(
   url: string,
-  options: Record<string, boolean> = { html: false, mobile: false },
+  options?: { html?: boolean; mobile?: boolean },
 ) {
   const reqOpts = {};
-  if (options.mobile) Object.assign(reqOpts, { headers: new Headers({ 'User-Agent': MOBILE_UA }) });
+
+  if (options?.mobile) {
+    Object.assign(reqOpts, { headers: new Headers({ 'User-Agent': MOBILE_UA }) });
+  }
+
   return fetch(url, reqOpts)
     .then((r) => r.text())
-    .then((r) => (options.html ? parseDom(r) : r));
+    .then((r) => (options?.html ? parseDom(r) : r));
 }
 
-export const fetchHtml = (url: string) => fetchWith(url, { html: true }) as Promise<HTMLElement>;
+export const fetchHtml = (url: string) =>
+  fetchWith(url, { html: true }) as Promise<HTMLElement>;
 
 export const fetchText = (url: string) => fetchWith(url) as Promise<string>;
 
-export function objectToFormData(object: Record<string, number | boolean | string>): FormData {
+export function objectToFormData<T extends {}>(obj: T): FormData {
   const formData = new FormData();
-  Object.entries(object).forEach(([k, v]) => formData.append(k, v as string));
+  Object.entries(obj).forEach(([k, v]) => {
+    formData.append(k, v as string);
+  });
   return formData;
 }

package/src/utils/objects/index.ts

@@ -0,0 +1,25 @@
+type AnyFunction = (...args: any[]) => any;
+
+export interface MemoizedFunction<T extends AnyFunction> extends CallableFunction {
+  (...args: Parameters<T>): ReturnType<T>;
+  clear: () => void;
+}
+
+export function memoize<T extends AnyFunction>(fn: T): MemoizedFunction<T> {
+  const cache = new Map<string, ReturnType<T>>();
+
+  const memoizedFunction = ((...args: Parameters<T>): ReturnType<T> => {
+    const key = JSON.stringify(args);
+
+    if (cache.has(key)) {
+      return cache.get(key) as ReturnType<T>;
+    }
+
+    const result = fn(...args);
+    cache.set(key, result);
+
+    return result;
+  }) as MemoizedFunction<T>;
+
+  return memoizedFunction;
+}

package/src/utils/observers/index.ts

@@ -1,5 +1,6 @@
 export class Observer {
   public observer: IntersectionObserver;
+  private timeout: number | null = null;
   constructor(private callback: (entry: Element) => void) {
     this.observer = new IntersectionObserver(this.handleIntersection.bind(this));
   }
@@ -10,7 +11,7 @@ export class Observer {
 
   throttle(target: Element, throttleTime: number) {
     this.observer.unobserve(target);
-    setTimeout(() => this.observer.observe(target), throttleTime);
+    this.timeout = setTimeout(() => this.observer.observe(target), throttleTime);
   }
 
   handleIntersection(entries: Iterable<IntersectionObserverEntry>) {
@@ -21,6 +22,11 @@ export class Observer {
     }
   }
 
+  dispose() {
+    if (this.timeout) clearTimeout(this.timeout);
+    this.observer.disconnect();
+  }
+
   static observeWhile(
     target: Element,
     callback: () => Promise<boolean> | boolean,
@@ -47,7 +53,7 @@ export class LazyImgLoader {
     });
   }
 
-  lazify(_target: Element, img: HTMLImageElement, imgSrc: string) {
+  lazify(_target: Element, img?: HTMLImageElement, imgSrc?: string) {
     if (!img || !imgSrc) return;
     img.setAttribute(this.attributeName, imgSrc);
     img.src = '';

package/src/utils/parsers/index.ts

@@ -13,29 +13,36 @@ export function timeToSeconds(t: string): number {
   const r = /sec|min|h|m/.test(t) ? formatTimeToHHMMSS(t) : t;
   return (r?.match(/\d+/gm) || [0])
     .reverse()
+
     .map((s, i) => parseInt(s as string) * 60 ** i)
     .reduce((a, b) => a + b);
 }
 
 export function parseIntegerOr(n: string | number, or: number): number {
-  return (num => Number.isNaN(num) ? or : num)(parseInt(n as string));
+  const num = Number(n);
+  return Number.isSafeInteger(num) ? num : or;
 }
 
 // "data:02;body+head:async;void:;zero:;"
 export function parseDataParams(str: string): Record<string, string> {
   const paramsStr = decodeURI(str.trim()).split(';');
-  return paramsStr.reduce((acc, s) => {
-    const parsed = s.match(/([\+\w]+):([\w\-\ ]+)?/);
-    if (parsed) {
-      const [, key, value] = parsed;
-      if (value) {
-        key.split('+').forEach(p => { acc[p] = value; });
+  return paramsStr.reduce(
+    (acc, s) => {
+      const parsed = s.match(/([+\w]+):([\w\- ]+)?/);
+      if (parsed) {
+        const [, key, value] = parsed;
+        if (value) {
+          key.split('+').forEach((p) => {
+            acc[p] = value;
+          });
+        }
       }
-    }
-    return acc;
-  }, {} as Record<string, string>);
+      return acc;
+    },
+    {} as Record<string, string>,
+  );
 }
 
 export function parseCSSUrl(s: string) {
-  return s.replace(/url\("|\"\).*/g, '');
+  return s.replace(/url\("|"\).*/g, '');
 }

package/src/utils/strings/index.ts

@@ -1,10 +1,10 @@
-export function stringToWords(s: string): Array<string> {
+export function splitWith(s: string, c: string = ','): Array<string> {
   return s
-    .split(',')
-    .map((s) => s.trim().toLowerCase())
-    .filter((_) => _);
+    .split(c)
+    .map((s) => s.trim())
+    .filter(Boolean);
 }
 
 export function sanitizeStr(s: string) {
-  return s?.replace(/\n|\t/g, ' ').replace(/ {2,}/g, ' ').trim().toLowerCase() || '';
+  return s?.replace(/\n|\t/g, ' ').replace(/ {2,}/g, ' ').trim() || '';
 }

package/src/utils/strings/regexes.ts

@@ -0,0 +1,31 @@
+import { memoize } from '../objects';
+import { splitWith } from '.';
+
+export class RegexFilter {
+  private regexes: RegExp[];
+
+  constructor(str: string, flags: string = 'i') {
+    this.regexes = memoize(this.compileSearchRegex)(str, flags);
+  }
+
+  // 'dog,bog,f:girl' or r:dog|bog... => [r/dog/i, r/bog/i, r/(^|\ )girl($|\ )/i]
+  private compileSearchRegex(str: string, flags: string): RegExp[] {
+    if (str.startsWith('r:')) return [new RegExp(str.slice(2), flags)];
+
+    const regexes = splitWith(str)
+      .map(
+        (s) => s.replace(/f:(\w+)/g, (_, w) => `(^|\\ |,)${w}($|\\ |,)`), // full word
+      )
+      .map((_) => new RegExp(_, flags));
+
+    return regexes;
+  }
+
+  public hasEvery(str: string) {
+    return this.regexes.every((r) => r.test(str));
+  }
+
+  public hasNone(str: string) {
+    return this.regexes.every((r) => !r.test(str));
+  }
+}

package/src/utils/userscript/index.ts

@@ -0,0 +1,10 @@
+export function getWindows(): Window[] {
+  return [window, unsafeWindow].filter(Boolean);
+}
+
+export function assignGlobals<T extends {}>(obj: T) {
+  const windows = getWindows();
+  windows.forEach((w: Window) => {
+    Object.assign(w, obj);
+  });
+}

package/src/userscripts/jabroni-outfit-wrap/index.ts

@@ -1,40 +0,0 @@
-import { InfiniteScroller } from '../infinite-scroll';
-import type { IRules } from '../rules';
-
-export interface JabroniStore {
-  state: Record<string, boolean | string | number>;
-  localState: Record<string, boolean | string | number>;
-  subscribe: (callback: () => void) => void;
-}
-
-export function createInfiniteScroller(
-  store: JabroniStore,
-  parseData: (document: HTMLElement) => void,
-  rules: IRules,
-) {
-  const enabled = store.state.infiniteScrollEnabled as boolean;
-
-  const paginationOffset = rules.paginationStrategy.getPaginationOffset();
-  const paginationElement = rules.paginationStrategy.getPaginationElement() as HTMLElement;
-  const paginationLast = rules.paginationStrategy.getPaginationLast();
-  const paginationUrlGenerator = rules.paginationStrategy.getPaginationUrlGenerator();
-
-  const iscroller = new InfiniteScroller({
-    enabled,
-    parseData,
-    paginationLast,
-    paginationOffset,
-    paginationElement,
-    paginationUrlGenerator,
-    ...rules,
-  }).onScroll(({ paginationLast, paginationOffset }) => {
-    store.localState.pagIndexLast = paginationLast;
-    store.localState.pagIndexCur = paginationOffset;
-  }, true);
-
-  store.subscribe(() => {
-    iscroller.enabled = store.state.infiniteScrollEnabled as boolean;
-  });
-
-  return iscroller;
-}