pervert-monkey 1.0.0

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

@@ -0,0 +1,66 @@
+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.overwritePaginationLast) return this.overwritePaginationLast(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/core/pagination-parsing/pagination-strategies/PaginationStrategyPathnameParams.ts

@@ -0,0 +1,77 @@
+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.overwritePaginationLast) return this.overwritePaginationLast(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/core/pagination-parsing/pagination-strategies/PaginationStrategySearchParams.ts

@@ -0,0 +1,56 @@
+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.overwritePaginationLast) return this.overwritePaginationLast(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/core/pagination-parsing/pagination-strategies/index.ts

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

package/src/core/pagination-parsing/pagination-utils/index.ts

@@ -0,0 +1,84 @@
+import { URLPattern } from 'urlpattern-polyfill/urlpattern';
+
+export function parseUrl(s: HTMLAnchorElement | Location | URL | string): URL {
+  return new URL(typeof s === 'string' ? s : s.href);
+}
+
+export function depaginatePathname(
+  url: URL,
+  pathnamePaginationSelector = /\/(page\/)?\d+\/?$/,
+): URL {
+  const newUrl = new URL(url.toString());
+  newUrl.pathname = newUrl.pathname.replace(pathnamePaginationSelector, '/');
+  return newUrl;
+}
+
+export function getPaginationLinks(
+  doc: Element | HTMLElement | Document = document,
+  url: Location | URL | string = location.href,
+  pathnamePaginationSelector = /\/(page\/)?\d+\/?$/,
+): string[] {
+  const baseUrl = depaginatePathname(parseUrl(url), pathnamePaginationSelector);
+  const pathnameStrict = doc instanceof Document;
+  const host = doc.baseURI || baseUrl.origin;
+
+  const urlPattern = new URLPattern({
+    pathname: pathnameStrict ? `${baseUrl.pathname}*` : '*',
+    hostname: baseUrl.hostname,
+  });
+
+  const pageLinks = [...doc.querySelectorAll<HTMLAnchorElement>('a[href]')]
+    .map((a) => a.href)
+    .filter((h) => URL.canParse(h));
+
+  return pageLinks.filter((h) => {
+    return urlPattern.test(new URL(h, host));
+  });
+}
+
+/**
+ * Nonsens
+ * WTF IS THIS? JFC...
+ * @description
+ * curr: website.com, links: [webiste.com/new/23] => wegsite.com/new
+ */
+export function upgradePathname(
+  curr: URL,
+  links: URL[],
+  pathnamePaginationSelector = /\/(page\/)?\d+\/?$/,
+): URL {
+  if (pathnamePaginationSelector.test(curr.pathname) || links.length < 1) return curr;
+
+  const linksDepaginated = links.map((l) =>
+    depaginatePathname(l, pathnamePaginationSelector),
+  );
+
+  if (linksDepaginated.some((l) => l.pathname === curr.pathname)) return curr;
+
+  const last = linksDepaginated.at(-1) as URL;
+  if (last.pathname !== curr.pathname) curr.pathname = last.pathname;
+  return curr;
+}
+
+/**
+ * @description
+ * website.com/search => website.com/search+word1...+-word2
+ */
+export function applyUrlLevelSearchFilters(
+  searchFilter: string,
+  queryType: keyof Pick<Location, 'pathname' | 'search'>,
+): void {
+  const wordsToFilter =
+    searchFilter.replace(/f:/g, '').match(/(?<!user:)\b\w+\b(?!\s*:)/g) || [];
+
+  if (!wordsToFilter.some((w) => !location.href.includes(w))) return;
+
+  let query = location[queryType];
+
+  wordsToFilter.forEach((w) => {
+    if (query.includes(w)) return;
+    query += `+-${w.trim()}`;
+  });
+
+  window.location[queryType] = query;
+}

package/src/core/rules/index.ts

@@ -0,0 +1,385 @@
+import { JabronioGUI, JabronioStore, type JabroniTypes, setupScheme } from 'jabroni-outfit';
+import {
+  getCommonParents,
+  querySelectorLast,
+  querySelectorText,
+  removeClassesAndDataAttributes,
+  waitForElementToDisappear,
+} from '../../utils/dom';
+import { timeToSeconds } from '../../utils/parsers';
+import { sanitizeStr } from '../../utils/strings';
+import { DataManager } from '../data-control';
+import type { DataSelectorFn } from '../data-control/data-filter';
+import { InfiniteScroller, type OffsetGenerator } from '../infinite-scroll/';
+import { DefaultScheme, type SchemeOptions } from '../jabroni-config/default-scheme';
+import { StoreStateDefault } from '../jabroni-config/default-store';
+import { getPaginationStrategy } from '../pagination-parsing';
+import type { PaginationStrategy } from '../pagination-parsing/pagination-strategies';
+
+type ThumbData = {
+  title: string;
+  duration?: number;
+} & { [x: string]: string | boolean | number };
+
+type _CustomThumbDataSelector = {
+  selector: string;
+  type: 'boolean' | 'string' | 'number';
+};
+
+type CustomThumbDataSelector = {
+  [x: string]: _CustomThumbDataSelector;
+};
+
+export class RulesGlobal {
+  public delay?: number;
+
+  public customGenerator?: OffsetGenerator;
+
+  public getThumbUrl(thumb: HTMLElement | HTMLAnchorElement) {
+    return ((thumb.querySelector('a[href]') || thumb) as HTMLAnchorElement).href;
+  }
+
+  public titleSelector: undefined | string;
+  public uploaderSelector: undefined | string;
+  public durationSelector: undefined | string;
+
+  public customThumbDataSelectors: undefined | CustomThumbDataSelector;
+  public getThumbDataStrategy: 'default' | 'auto-select' | 'auto-text' = 'default';
+
+  public getThumbDataCallback?: (thumb: HTMLElement, thumbData: ThumbData) => void;
+
+  public getThumbData(thumb: HTMLElement): ThumbData {
+    let { titleSelector, uploaderSelector, durationSelector } = this;
+    const thumbData: ThumbData = { title: '' };
+
+    if (this.getThumbDataStrategy === 'auto-text') {
+      const text = sanitizeStr(thumb.innerText);
+      thumbData.title = text;
+      thumbData.duration = timeToSeconds(text.match(/\d+m|\d+:\d+/)?.[0] || '');
+      return thumbData;
+    }
+
+    if (this.getThumbDataStrategy === 'auto-select') {
+      titleSelector = '[class *= title],[title]';
+      durationSelector = '[class *= duration]';
+      uploaderSelector = '[class *= uploader], [class *= user], [class *= name]';
+    }
+
+    if (this.getThumbDataStrategy === 'auto-select') {
+      const selected = querySelectorLast(thumb, titleSelector as string);
+      if (selected) {
+        thumbData.title = sanitizeStr(selected.innerText as string);
+      } else {
+        thumbData.title = sanitizeStr(thumb.innerText);
+      }
+    } else {
+      thumbData.title = querySelectorText(thumb, titleSelector);
+    }
+
+    if (uploaderSelector) {
+      const uploader = querySelectorText(thumb, uploaderSelector);
+      thumbData.title = `${thumbData.title} user:${uploader}`;
+    }
+
+    if (durationSelector) {
+      const duration = timeToSeconds(querySelectorText(thumb, durationSelector));
+      thumbData.duration = duration;
+    }
+
+    this.getThumbDataCallback?.(thumb, thumbData);
+
+    function getCustomThumbData(
+      selector: _CustomThumbDataSelector['selector'],
+      type: _CustomThumbDataSelector['type'],
+    ): string | number | boolean {
+      if (type === 'boolean') {
+        return !!thumb.querySelector(selector);
+      }
+      if (type === 'string') {
+        return querySelectorText(thumb, selector);
+      }
+      return Number.parseInt(querySelectorText(thumb, selector));
+    }
+
+    if (this.customThumbDataSelectors) {
+      Object.entries(this.customThumbDataSelectors).forEach(([name, x]) => {
+        const data = getCustomThumbData(x.selector, x.type);
+        Object.assign(thumbData, { [name]: data });
+      });
+    }
+
+    return thumbData;
+  }
+
+  public getThumbImgDataAttrSelector?:
+    | string
+    | string[]
+    | ((img: HTMLImageElement) => string);
+  public getThumbImgDataAttrDelete?: 'auto' | string;
+  public getThumbImgDataStrategy: 'default' | 'auto' = 'default';
+
+  public getThumbImgData(thumb: HTMLElement) {
+    const result: { img?: HTMLImageElement; imgSrc?: string } = {};
+
+    if (this.getThumbImgDataStrategy === 'auto') {
+      const img = thumb.querySelector<HTMLImageElement>('img');
+      if (!img) return {};
+
+      result.img = img;
+
+      if (typeof this.getThumbImgDataAttrSelector === 'function') {
+        result.imgSrc = this.getThumbImgDataAttrSelector(img);
+      } else {
+        const possibleAttrs = this.getThumbImgDataAttrSelector
+          ? [this.getThumbImgDataAttrSelector].flat()
+          : ['data-src', 'src'];
+
+        for (const attr of possibleAttrs) {
+          const imgSrc = img.getAttribute(attr);
+          if (imgSrc) {
+            result.imgSrc = imgSrc;
+            img.removeAttribute(attr);
+            break;
+          }
+        }
+      }
+
+      if (this.getThumbImgDataAttrDelete) {
+        if (this.getThumbImgDataAttrDelete === 'auto') {
+          removeClassesAndDataAttributes(img, 'lazy');
+        } else {
+          if (this.getThumbImgDataAttrDelete.startsWith('.')) {
+            img.classList.remove(this.getThumbImgDataAttrDelete.slice(1));
+          } else {
+            img.removeAttribute(this.getThumbImgDataAttrDelete);
+          }
+        }
+
+        if (img.src.includes('data:image')) {
+          result.img.src = '';
+        }
+
+        if (img.complete && img.naturalWidth > 0) {
+          return {};
+        }
+      }
+    }
+
+    return result;
+  }
+
+  public containerSelector: string | (() => HTMLElement) = '.container';
+  public containerSelectorLast?: string;
+
+  public intersectionObservableSelector?: string;
+
+  public get intersectionObservable() {
+    return (
+      this.intersectionObservableSelector &&
+      document.querySelector(this.intersectionObservableSelector)
+    );
+  }
+
+  public get observable(): HTMLElement {
+    return (this.intersectionObservable ||
+      this.paginationStrategy.getPaginationElement()) as HTMLElement;
+  }
+
+  get container() {
+    if (typeof this.containerSelectorLast === 'string') {
+      return querySelectorLast(document, this.containerSelectorLast) as HTMLElement;
+    }
+    if (typeof this.containerSelector === 'string') {
+      return document.querySelector<HTMLElement>(this.containerSelector) as HTMLElement;
+    }
+    return this.containerSelector();
+  }
+
+  public thumbsSelector = '.thumb';
+  public getThumbsStrategy: 'default' | 'auto' = 'default';
+  public getThumbsTransform?: (thumb: HTMLElement) => void;
+
+  public getThumbs(html: HTMLElement): HTMLElement[] {
+    if (!html) return [];
+    let thumbs: HTMLElement[];
+
+    if (this.getThumbsStrategy === 'auto') {
+      if (typeof this.containerSelector !== 'string') return [];
+      const container = html.querySelector(this.containerSelector);
+      thumbs = [...(container?.children || [])] as HTMLElement[];
+    }
+
+    thumbs = Array.from(html.querySelectorAll<HTMLElement>(this.thumbsSelector));
+
+    if (typeof this.getThumbsTransform === 'function') {
+      thumbs.forEach(this.getThumbsTransform);
+    }
+
+    return thumbs;
+  }
+
+  public paginationStrategyOptions: Partial<PaginationStrategy> = {};
+  public paginationStrategy: PaginationStrategy;
+
+  public customDataSelectorFns: (Record<string, DataSelectorFn<any>> | string)[] = [
+    'filterInclude',
+    'filterExclude',
+    'filterDuration',
+  ];
+
+  public animatePreview?: (doc: HTMLElement) => void;
+
+  public storeOptions?: JabroniTypes.StoreStateOptions;
+
+  private createStore() {
+    const config = { ...StoreStateDefault, ...this.storeOptions };
+    this.store = new JabronioStore(config);
+    return this.store;
+  }
+
+  public schemeOptions: SchemeOptions = [];
+
+  private createGui() {
+    const scheme = setupScheme(
+      this.schemeOptions as Parameters<typeof setupScheme>[0],
+      DefaultScheme,
+    );
+    this.gui = new JabronioGUI(scheme, this.store);
+    return this.gui;
+  }
+
+  public store: JabronioStore;
+  public gui: JabronioGUI;
+  public dataManager: DataManager;
+
+  public infiniteScroller?: InfiniteScroller;
+  public getPaginationData?: InfiniteScroller['getPaginationData'];
+
+  private resetInfiniteScroller() {
+    this.infiniteScroller?.dispose();
+    if (!this.paginationStrategy.hasPagination) return;
+    this.infiniteScroller = InfiniteScroller.create(this);
+  }
+
+  public gropeStrategy: 'all-in-one' | 'all-in-all' = 'all-in-one';
+
+  public gropeInit() {
+    if (!this.gropeStrategy) return;
+    if (this.gropeStrategy === 'all-in-one') {
+      this.dataManager?.parseData(this.container, this.container);
+    }
+    if (this.gropeStrategy === 'all-in-all') {
+      getCommonParents(this.getThumbs(document.body)).forEach((c) => {
+        this.dataManager.parseData(c, c, true);
+      });
+    }
+  }
+
+  public get isEmbedded() {
+    return window.self !== window.top;
+  }
+
+  private setupStoreListeners() {
+    const eventsMap = {
+      'sort by duration': {
+        action: (direction: boolean) => this.dataManager.sortBy('duration', direction),
+      },
+    };
+
+    let lastEvent: undefined | string;
+    let direction = true;
+
+    this.store.eventSubject.subscribe((event) => {
+      if (event === lastEvent) {
+        direction = !direction;
+      } else {
+        lastEvent = event;
+        direction = true;
+      }
+
+      if (event in eventsMap) {
+        const ev = eventsMap[event as keyof typeof eventsMap];
+        ev?.action(direction);
+      }
+    });
+
+    this.store.stateSubject.subscribe((a) => {
+      this.dataManager.applyFilters(a as { [key: string]: boolean });
+    });
+  }
+
+  public dataManagerOptions: Partial<DataManager> = {};
+
+  private setupDataManager() {
+    this.dataManager = new DataManager(this);
+    if (this.dataManagerOptions) {
+      Object.assign(this.dataManager, this.dataManagerOptions);
+    }
+
+    return this.dataManager;
+  }
+
+  private mutationObservers: MutationObserver[] = [];
+
+  public resetOnPaginationOrContainerDeath = true;
+
+  private resetOn() {
+    if (!this.resetOnPaginationOrContainerDeath) return;
+
+    const observables = [
+      this.container,
+      this.intersectionObservable || this.paginationStrategy.getPaginationElement(),
+    ].filter(Boolean);
+
+    if (observables.length === 0) return;
+
+    observables.forEach((o) => {
+      const observer = waitForElementToDisappear(o as HTMLElement, () => {
+        this.reset();
+      });
+      this.mutationObservers.push(observer);
+    });
+  }
+
+  public onResetCallback?: () => void;
+
+  private reset() {
+    // console.log('\nRESET\n');
+
+    this.mutationObservers.forEach((o) => {
+      o.disconnect();
+    });
+    this.mutationObservers = [];
+
+    this.paginationStrategy = getPaginationStrategy(this.paginationStrategyOptions);
+
+    this.setupDataManager();
+    this.setupStoreListeners();
+
+    this.resetInfiniteScroller();
+
+    this.container && this.animatePreview?.(this.container);
+
+    this.gropeInit();
+
+    this.onResetCallback?.();
+
+    this.resetOn();
+  }
+
+  constructor(options: Partial<RulesGlobal>) {
+    if (this.isEmbedded) throw Error('Embedded is not supported');
+
+    Object.assign(this, options);
+
+    this.paginationStrategy = getPaginationStrategy(this.paginationStrategyOptions);
+
+    this.store = this.createStore();
+    this.gui = this.createGui();
+
+    this.dataManager = this.setupDataManager();
+
+    this.reset();
+    // console.log('data', this.dataManager.data.values().toArray());
+  }
+}