billy-herrington-utils 2.0.7 → 2.1.0

package/src/userscripts/data-manager/data-filter.ts

@@ -1,110 +0,0 @@
-import type { StoreState } from 'jabroni-outfit';
-import { RegexFilter } from '../../utils/strings/regexes';
-import type { RulesGlobal } from '../rules';
-import type { DataElement } from '.';
-
-export type CustomSelector<R> = {
-  handle: (el: DataElement, state: StoreState, $preDefineResult?: R) => boolean;
-  $preDefine?: (state: StoreState) => R;
-};
-
-interface FilterResult {
-  tag: string;
-  condition: boolean;
-}
-
-export type FilterFunction = (v: DataElement) => FilterResult;
-
-export class DataFilter {
-  public filters = new Map<string, () => FilterFunction>();
-
-  constructor(
-    private rules: RulesGlobal,
-    private state: StoreState,
-  ) {
-    this.registerFilters(DataFilter.customFiltersDefault);
-    this.registerFilters(rules.customSelectors);
-    this.applyCSSFilters();
-  }
-
-  public applyCSSFilters() {
-    Object.keys(this.filters).forEach((name) => {
-      const className = `.filter-${name.toLowerCase().slice(6)}`;
-      GM_addStyle(`${className} { display: none !important; content-visibility: auto; }`);
-    });
-  }
-
-  public registerFilters(customFilters: Record<string, CustomSelector<any>>) {
-    Object.entries(customFilters).forEach(([k, v]) => {
-      if (!Object.hasOwn(this.rules.customSelectors, k)) {
-        this.rules.customSelectors[k] = v;
-      }
-      this.registerFilter(k);
-    });
-  }
-
-  public registerFilter(CustomSelectorName: string) {
-    const handler = this.rules.customSelectors[CustomSelectorName];
-
-    const fn = (): FilterFunction => {
-      const preDefined = handler.$preDefine?.(this.state);
-
-      return (v: DataElement) => {
-        const result = handler.handle(v, this.state, preDefined);
-
-        return {
-          condition: result,
-          tag: `filter-${CustomSelectorName}`,
-        };
-      };
-    };
-
-    this.filters.set(CustomSelectorName, fn);
-  }
-
-  static customFiltersDefault: Record<string, CustomSelector<any>> = {
-    isPrivate: {
-      handle(el, state) {
-        const isPrivate = !!(el.element as HTMLElement).querySelector('.private');
-        return (state.filterPrivate as boolean) && isPrivate;
-      },
-    },
-    isPublic: {
-      handle(el, state) {
-        const isPublic = !!(el.element as HTMLElement).querySelector('.public');
-        return (state.filterPublic as boolean) && isPublic;
-      },
-    },
-    filterDuration: {
-      handle(el, state, preDefined) {
-        const d = el.duration as number;
-        const notInRange = d < (preDefined.from as number) || d > (preDefined.to as number);
-        return (state.filterDuration as boolean) && notInRange;
-      },
-      $preDefine: (state) => {
-        const f = (x: number) => (state.filterDurationMinutes ? x * 60 : x);
-        const from = f(state.filterDurationFrom as number);
-        const to = f(state.filterDurationTo as number);
-        return { from, to };
-      },
-    },
-    filterExclude: {
-      handle(el, state, searchFilter) {
-        return (
-          (state.filterExclude as boolean) &&
-          (searchFilter as RegexFilter).hasNone(el.title as string)
-        );
-      },
-      $preDefine: (state) => new RegexFilter(state.filterExcludeWords as string),
-    },
-    filterInclude: {
-      handle(el, state, searchFilter) {
-        return (
-          (state.filterInclude as boolean) &&
-          (searchFilter as RegexFilter).hasEvery(el.title as string)
-        );
-      },
-      $preDefine: (state) => new RegexFilter(state.filterIncludeWords as string),
-    },
-  };
-}

package/src/userscripts/data-manager/index.ts

@@ -1,141 +0,0 @@
-import type { StoreState } from 'jabroni-outfit';
-import { LazyImgLoader } from '../../utils/observers';
-import { assignGlobals } from '../../utils/userscript';
-import type { RulesGlobal } from '../rules';
-import { DataFilter, type FilterFunction } from './data-filter';
-
-export type DataElement = Record<string, string | number | boolean | HTMLElement>;
-
-export class DataManager {
-  private data = new Map<string, DataElement>();
-  private lazyImgLoader = new LazyImgLoader(
-    (target: Element) => !this.isFiltered(target as HTMLElement),
-  );
-  private dataFilter: DataFilter;
-
-  constructor(
-    private rules: RulesGlobal,
-    private state: StoreState,
-  ) {
-    this.dataFilter = new DataFilter(rules, state);
-
-    assignGlobals({
-      sortByDuration: () => this.sortBy('duration'),
-      sortByViews: () => this.sortBy('view'),
-    });
-  }
-
-  public isFiltered(el: HTMLElement): boolean {
-    return el.className.includes('filtered');
-  }
-
-  public applyFilters = (filters: { [key: string]: boolean } = {}, offset = 0): void => {
-    const filtersToApply = Object.keys(filters)
-      .filter((k) => this.dataFilter.filters.has(k))
-      .map((k) => this.dataFilter.filters.get(k) as () => FilterFunction);
-
-    if (filtersToApply.length === 0) return;
-
-    const iterator = this.data.values();
-    let currentIndex = 0;
-
-    const runBatch = (deadline: IdleDeadline) => {
-      while (currentIndex < offset) {
-        const skip = iterator.next();
-        if (skip.done) return;
-        currentIndex++;
-      }
-
-      const updates: { e: HTMLElement; tag: string; condition: boolean }[] = [];
-
-      while (deadline.timeRemaining() > 0) {
-        const { value, done } = iterator.next();
-        if (done) break;
-
-        for (const f of filtersToApply) {
-          const { tag, condition } = f()(value);
-          updates.push({ e: value.element as HTMLElement, tag, condition });
-        }
-      }
-
-      if (updates.length > 0) {
-        requestAnimationFrame(() => {
-          updates.forEach((u) => {
-            u.e.classList.toggle(u.tag, u.condition);
-          });
-        });
-      }
-
-      if (currentIndex < this.data.size) {
-        requestIdleCallback(runBatch);
-      }
-    };
-
-    requestIdleCallback(runBatch);
-  };
-
-  public filterAll = (offset?: number): void => {
-    const filters = Object.assign(
-      {},
-      ...Object.keys(this.dataFilter.filters).map((f) => ({
-        [f]: this.state[f as keyof StoreState],
-      })),
-    );
-    this.applyFilters(filters, offset);
-  };
-
-  public parseData = (
-    html: HTMLElement,
-    container?: HTMLElement,
-    removeDuplicates = false,
-    shouldLazify = true,
-  ): void => {
-    const thumbs = this.rules.getThumbs(html);
-    const data_offset = this.data.size;
-    const fragment = document.createDocumentFragment();
-    const parent = container || this.rules.container;
-
-    for (const thumbElement of thumbs) {
-      const url = this.rules.getThumbUrl(thumbElement);
-      if (!url || this.data.has(url) || parent.contains(thumbElement)) {
-        if (removeDuplicates) thumbElement.remove();
-        continue;
-      }
-
-      const data = this.rules.getThumbData(thumbElement);
-      this.data.set(url, { element: thumbElement, ...data });
-
-      if (shouldLazify) {
-        const { img, imgSrc } = this.rules.getThumbImgData(thumbElement);
-        this.lazyImgLoader.lazify(thumbElement, img, imgSrc);
-      }
-
-      fragment.append(thumbElement);
-    }
-
-    requestAnimationFrame(() => {
-      parent.appendChild(fragment);
-    });
-
-    this.filterAll(data_offset);
-  };
-
-  public sortBy<K extends keyof DataElement>(key: K): void {
-    if (this.data.size < 2) return;
-
-    const sorted: DataElement[] = Array.from(this.data.values()).sort(
-      (a: DataElement, b: DataElement) => {
-        return (a[key] as number) - (b[key] as number);
-      },
-    );
-
-    const container = (sorted[0].element as HTMLElement).parentElement as HTMLElement;
-    container.style.visibility = 'hidden';
-
-    sorted.forEach((s) => {
-      container.append(s.element as HTMLElement);
-    });
-
-    container.style.visibility = 'visible';
-  }
-}

package/src/userscripts/infinite-scroll/index.ts

@@ -1,106 +0,0 @@
-import type { JabronioStore } from 'jabroni-outfit';
-import { fetchHtml } from '../../utils/fetch';
-import { Observer } from '../../utils/observers';
-import type { RulesGlobal } from '../rules';
-
-type InfiniteScrollerOptions = Pick<InfiniteScroller, 'rules'> & Partial<InfiniteScroller>;
-type GeneratorResult = { url: string; offset: number };
-export type OffsetGenerator = Generator<GeneratorResult> | AsyncGenerator<GeneratorResult>;
-
-export class InfiniteScroller {
-  public enabled = true;
-  public delay = 200;
-  public paginationOffset = 1;
-  public writeHistory = false;
-  public parseData?: (document: HTMLElement) => void;
-  public rules: RulesGlobal;
-
-  private observer?: Observer;
-  private paginationGenerator: OffsetGenerator;
-
-  constructor(options: InfiniteScrollerOptions) {
-    this.rules = options.rules;
-    this.paginationOffset = this.rules.paginationStrategy.getPaginationOffset();
-    Object.assign(this, options);
-
-    this.paginationGenerator = this.createPaginationGenerator();
-    this.setObserver(this.rules.observable);
-  }
-
-  public dispose() {
-    if (this.observer) this.observer.dispose();
-  }
-
-  public setObserver(observable: HTMLElement) {
-    if (this.observer) this.observer.dispose();
-    this.observer = Observer.observeWhile(observable, this.generatorConsumer, this.delay);
-    return this;
-  }
-
-  private onScrollCBs: Array<(scroller: InfiniteScroller) => void> = [];
-
-  public onScroll(callback: (scroller: InfiniteScroller) => void, initCall = false) {
-    if (initCall) callback(this);
-    this.onScrollCBs.push(callback);
-    return this;
-  }
-
-  private _onScroll() {
-    this.onScrollCBs.forEach((cb) => {
-      cb(this);
-    });
-  }
-
-  generatorConsumer = async () => {
-    if (!this.enabled) return false;
-    const { value: { url, offset } = {}, done } = await this.paginationGenerator.next();
-    if (!done) {
-      await this.doScroll(url, offset);
-    }
-    return !done;
-  };
-
-  async doScroll(url: string, offset: number) {
-    const nextPageHTML = await fetchHtml(url);
-    const prevScrollPos = document.documentElement.scrollTop;
-    this.paginationOffset = Math.max(this.paginationOffset, offset);
-    this.parseData?.(nextPageHTML);
-    this._onScroll();
-    window.scrollTo(0, prevScrollPos);
-    if (this.writeHistory) {
-      history.replaceState({}, '', url);
-    }
-  }
-
-  private *createPaginationGenerator(): OffsetGenerator {
-    const curPage = this.rules.paginationStrategy.getPaginationOffset();
-    const lastPage = this.rules.paginationStrategy.getPaginationLast();
-    for (let offset = curPage + 1; offset <= lastPage; offset++) {
-      const url = this.rules.paginationStrategy.getPaginationUrlGenerator()(offset);
-      yield { url, offset };
-    }
-  }
-
-  static create(
-    store: JabronioStore,
-    rules: RulesGlobal,
-    parseData: (document: HTMLElement) => void,
-  ) {
-    const enabled = store.state.infiniteScrollEnabled as boolean;
-
-    store.state.$paginationLast = rules.paginationStrategy.getPaginationLast();
-
-    const infiniteScroller = new InfiniteScroller({ enabled, parseData, rules }).onScroll(
-      ({ paginationOffset }) => {
-        store.state.$aginationOffset = paginationOffset;
-      },
-      true,
-    );
-
-    store.subscribe(() => {
-      infiniteScroller.enabled = store.state.infiniteScrollEnabled as boolean;
-    });
-
-    return infiniteScroller;
-  }
-}

package/src/userscripts/pagination-parsing/index.ts

@@ -1,55 +0,0 @@
-import {
-  PaginationStrategy,
-  PaginationStrategyDataParams,
-  PaginationStrategyPathnameParams,
-  PaginationStrategySearchParams,
-} from './pagination-strategies';
-import { getPaginationLinks } from './pagination-utils';
-
-export function getPaginationStrategy(
-  options: Partial<PaginationStrategy>,
-): PaginationStrategy {
-  const _paginationStrategy = new PaginationStrategy(options);
-  const pagination = _paginationStrategy.getPaginationElement();
-
-  Object.assign(options, { ..._paginationStrategy });
-  const { url, searchParamSelector } = options;
-
-  if (!pagination) {
-    console.error('Found No Pagination');
-    return _paginationStrategy;
-  }
-
-  const pageLinks = getPaginationLinks(pagination, url).map((l) => new URL(l));
-
-  console.log({ pageLinks: pageLinks.map((l) => l.href) });
-
-  const selectStrategy = (): typeof PaginationStrategy => {
-    if (PaginationStrategyDataParams.testLinks(pagination)) {
-      return PaginationStrategyDataParams;
-    }
-
-    if (PaginationStrategySearchParams.testLinks(pageLinks, searchParamSelector)) {
-      return PaginationStrategySearchParams;
-    }
-
-    if (PaginationStrategyPathnameParams.testLinks(pageLinks, options)) {
-      return PaginationStrategyPathnameParams;
-    }
-
-    console.error('Found No Strategy');
-    return PaginationStrategy;
-  };
-
-  const PaginationStrategyConstructor = selectStrategy();
-  const paginationStrategy = new PaginationStrategyConstructor(options);
-
-  console.log(
-    'paginationStrategy:',
-    PaginationStrategyConstructor.name,
-    '\n',
-    paginationStrategy,
-  );
-
-  return paginationStrategy;
-}

package/src/userscripts/pagination-parsing/pagination-strategies/PaginationStrategy.ts

@@ -1,42 +0,0 @@
-import { parseURL } from '../pagination-utils';
-
-export class PaginationStrategy {
-  public doc = document;
-  public url: URL;
-  public paginationSelector = '.pagination';
-  public searchParamSelector = 'page';
-  public static _pathnameSelector = /\/(page\/)?\d+\/?$/;
-  public pathnameSelector = /\/(\d+)\/?$/;
-  public dataparamSelector = '[data-parameters *= from]';
-  public fixPaginationLast?: (n: number, offset?: number) => number;
-  public offsetMin = 1;
-
-  constructor(options?: Partial<PaginationStrategy>) {
-    if (options) {
-      Object.entries(options).forEach(([k, v]) => {
-        Object.assign(this, { [k]: v });
-      });
-    }
-
-    this.url = parseURL(options?.url || this.doc.URL);
-  }
-
-  getPaginationElement() {
-    return this.doc.querySelector<HTMLElement>(this.paginationSelector);
-  }
-
-  get hasPagination() {
-    return !!this.getPaginationElement();
-  }
-
-  getPaginationOffset() {
-    return this.offsetMin;
-  }
-  getPaginationLast() {
-    return this.offsetMin;
-  }
-
-  getPaginationUrlGenerator() {
-    return (_: number) => this.url.href;
-  }
-}

package/src/userscripts/pagination-parsing/pagination-strategies/PaginationStrategyDataParams.ts

@@ -1,66 +0,0 @@
-import { parseDataParams } from '../../../utils/parsers';
-import { PaginationStrategy } from './PaginationStrategy';
-
-export class PaginationStrategyDataParams extends PaginationStrategy {
-  getPaginationLast() {
-    const links = this.getPaginationElement()?.querySelectorAll(this.dataparamSelector);
-    const pages = Array.from(links || [], (l) => {
-      const p = l.getAttribute('data-parameters');
-      const v = p?.match(/from\w*:(\d+)/)?.[1] || this.offsetMin.toString();
-      return parseInt(v);
-    });
-    const lastPage = Math.max(...pages, this.offsetMin);
-    if (this.fixPaginationLast) return this.fixPaginationLast(lastPage);
-    return lastPage;
-  }
-
-  getPaginationOffset() {
-    const link = this.getPaginationElement()?.querySelector(
-      '.prev[data-parameters *= from], .prev [data-parameters *= from]',
-    );
-    if (!link) return this.offsetMin;
-    const p = link.getAttribute('data-parameters');
-    const v = p?.match(/from\w*:(\d+)/)?.[1] || this.offsetMin.toString();
-    return parseInt(v);
-  }
-
-  getPaginationUrlGenerator() {
-    const url = new URL(this.url.href);
-
-    const parametersElement = this.getPaginationElement()?.querySelector(
-      'a[data-block-id][data-parameters]',
-    );
-    const block_id = parametersElement?.getAttribute('data-block-id') || '';
-    const parameters = parseDataParams(
-      parametersElement?.getAttribute('data-parameters') || '',
-    );
-
-    const attrs: Record<string, string> = {
-      block_id,
-      function: 'get_block',
-      mode: 'async',
-      ...parameters,
-    };
-
-    Object.keys(attrs).forEach((k) => {
-      url.searchParams.set(k, attrs[k]);
-    });
-
-    const paginationUrlGenerator = (n: number) => {
-      Object.keys(attrs).forEach((k) => {
-        k.includes('from') && url.searchParams.set(k, n.toString());
-      });
-      url.searchParams.set('_', Date.now().toString());
-      return url.href;
-    };
-
-    return paginationUrlGenerator;
-  }
-
-  static testLinks(doc: HTMLElement | Document = document) {
-    const dataParamLinks = Array.from(
-      doc.querySelectorAll<HTMLElement>('[data-parameters *= from]'),
-    );
-    return dataParamLinks.length > 0;
-  }
-}

package/src/userscripts/pagination-parsing/pagination-strategies/PaginationStrategyPathnameParams.ts

@@ -1,77 +0,0 @@
-import { getPaginationLinks, parseURL, upgradePathname } from '../pagination-utils';
-import { PaginationStrategy } from './PaginationStrategy';
-
-export class PaginationStrategyPathnameParams extends PaginationStrategy {
-  extractPage = (a: HTMLAnchorElement | Location | string): number => {
-    const href = typeof a === 'string' ? a : a.href;
-    const { pathname } = new URL(href, this.doc.baseURI || this.url.origin);
-    return parseInt(
-      pathname.match(this.pathnameSelector)?.pop() || this.offsetMin.toString(),
-    );
-  };
-
-  static checkLink(
-    link: URL,
-    pathnameSelector: RegExp = PaginationStrategy._pathnameSelector,
-  ): boolean {
-    return pathnameSelector.test(link.pathname);
-  }
-
-  static testLinks(links: URL[], options: Partial<PaginationStrategy>): boolean {
-    const result = links.some((h) =>
-      PaginationStrategyPathnameParams.checkLink(h, options.pathnameSelector),
-    );
-
-    if (result) {
-      const pathnamesMatched = links.filter((h) =>
-        PaginationStrategyPathnameParams.checkLink(h, options.pathnameSelector),
-      );
-      options.url = upgradePathname(
-        parseURL(options.url as unknown as string),
-        pathnamesMatched,
-      );
-    }
-
-    return result;
-  }
-
-  getPaginationLast() {
-    const links = getPaginationLinks(
-      (this.getPaginationElement() || document) as HTMLElement,
-      this.url.href,
-      this.pathnameSelector,
-    );
-    const pages = Array.from(links, this.extractPage);
-    const lastPage = Math.max(...pages, this.offsetMin);
-    if (this.fixPaginationLast) return this.fixPaginationLast(lastPage);
-    return lastPage;
-  }
-
-  getPaginationOffset() {
-    return this.extractPage(this.url.href);
-  }
-
-  getPaginationUrlGenerator(url_: URL = this.url) {
-    const url = new URL(url_.href);
-
-    const pathnameSelectorPlaceholder = this.pathnameSelector
-      .toString()
-      .replace(/[/|\\|$|?|(|)]+/g, '/');
-
-    if (!this.pathnameSelector.test(url.pathname)) {
-      url.pathname = url.pathname
-        .concat(pathnameSelectorPlaceholder.replace(/d\+/, this.offsetMin.toString()))
-        .replace(/\/{2,}/g, '/');
-    }
-
-    const paginationUrlGenerator = (offset: number) => {
-      url.pathname = url.pathname.replace(
-        this.pathnameSelector,
-        pathnameSelectorPlaceholder.replace(/d\+/, offset.toString()),
-      );
-      return url.href;
-    };
-
-    return paginationUrlGenerator;
-  }
-}

package/src/userscripts/pagination-parsing/pagination-strategies/PaginationStrategySearchParams.ts

@@ -1,56 +0,0 @@
-import { getPaginationLinks } from '../pagination-utils';
-import { PaginationStrategy } from './PaginationStrategy';
-
-export class PaginationStrategySearchParams extends PaginationStrategy {
-  extractPage = (a: HTMLAnchorElement | Location | URL | string): number => {
-    const href = typeof a === 'string' ? a : a.href;
-    const p = new URL(href).searchParams.get(this.searchParamSelector) as string;
-    return parseInt(p) || this.offsetMin;
-  };
-
-  getPaginationLast() {
-    const links = getPaginationLinks(
-      (this.getPaginationElement() || document) as HTMLElement,
-      this.url.href,
-    ).filter((h) =>
-      PaginationStrategySearchParams.checkLink(new URL(h), this.searchParamSelector),
-    );
-    const pages = links.map(this.extractPage);
-    const lastPage = Math.max(...pages, this.offsetMin);
-    if (this.fixPaginationLast) return this.fixPaginationLast(lastPage);
-    return lastPage;
-  }
-
-  getPaginationOffset() {
-    if (this.doc === document) {
-      return this.extractPage(this.url);
-    }
-    const link = this.getPaginationElement()?.querySelector(
-      `a.active[href *= "${this.searchParamSelector}="]`,
-    ) as HTMLAnchorElement;
-    return this.extractPage(link);
-  }
-
-  getPaginationUrlGenerator() {
-    const url = new URL(this.url.href);
-
-    const paginationUrlGenerator = (offset: number) => {
-      url.searchParams.set(this.searchParamSelector, offset.toString());
-      return url.href;
-    };
-
-    return paginationUrlGenerator;
-  }
-
-  static checkLink(link: URL, searchParamSelector?: string): boolean {
-    const searchParamSelectors = ['page', 'p'];
-    if (searchParamSelector) searchParamSelectors.push(searchParamSelector);
-    return searchParamSelectors.some((p) => link.searchParams.get(p) !== null);
-  }
-
-  static testLinks(links: URL[], searchParamSelector?: string) {
-    return links.some((h) =>
-      PaginationStrategySearchParams.checkLink(h, searchParamSelector),
-    );
-  }
-}

package/src/userscripts/pagination-parsing/pagination-strategies/PaginationStrategyTrash.ts

@@ -1,33 +0,0 @@
-import { fetchHtml } from '../../../utils/fetch';
-import { PaginationStrategy } from './PaginationStrategy';
-
-export class PaginationStrategyTrash extends PaginationStrategy {
-  getPaginationLast() {
-    return 9999;
-  }
-
-  getPaginationOffset() {
-    return this.offsetMin;
-  }
-
-  eHentaiNext = async () => {
-    if (!(unsafeWindow as any).PAGINATION_NEXT) {
-      const hrefs = [
-        ...document.querySelectorAll('a#dnext[href]'),
-      ] as Array<HTMLAnchorElement>;
-      (unsafeWindow as any).PAGINATION_NEXT = hrefs.pop()?.href;
-    }
-    const doc = await fetchHtml((unsafeWindow as any).PAGINATION_NEXT as string);
-    const hrefs = [...doc.querySelectorAll('a#dnext[href]')] as Array<HTMLAnchorElement>;
-    (unsafeWindow as any).PAGINATION_NEXT = hrefs.pop()?.href;
-  };
-
-  getPaginationUrlGenerator() {
-    const paginationUrlGenerator = (_: number) => {
-      this.eHentaiNext();
-      return (unsafeWindow as any).PAGINATION_NEXT as string;
-    };
-
-    return paginationUrlGenerator;
-  }
-}

package/src/userscripts/pagination-parsing/pagination-strategies/index.ts

@@ -1,5 +0,0 @@
-export { PaginationStrategy } from './PaginationStrategy';
-export { PaginationStrategyDataParams } from './PaginationStrategyDataParams';
-export { PaginationStrategyPathnameParams } from './PaginationStrategyPathnameParams';
-export { PaginationStrategySearchParams } from './PaginationStrategySearchParams';
-export { PaginationStrategyTrash } from './PaginationStrategyTrash';