pervert-monkey 1.0.9 → 1.0.10

package/src/core/parsers/thumb-img-parser.ts

@@ -0,0 +1,62 @@
+import { removeClassesAndDataAttributes } from "../../utils";
+
+export class ThumbImgParser {
+  public selector?: string | string[] | ((img: HTMLImageElement) => string);
+  public shouldDelete?: 'auto' | string;
+  public strategy: 'default' | 'auto' = 'default';
+
+  public static create(options: Partial<Pick<ThumbImgParser, 'selector' | 'shouldDelete' | 'strategy' | 'getImgData'>> = {}) {
+    return Object.assign(new ThumbImgParser(), options);
+  }
+
+  public getImgData(thumb: HTMLElement) {
+    const result: { img?: HTMLImageElement; imgSrc?: string } = {};
+
+    if (this.strategy === 'auto') {
+      const img = thumb.querySelector<HTMLImageElement>('img');
+      if (!img) return {};
+
+      result.img = img;
+
+      if (typeof this.selector === 'function') {
+        result.imgSrc = this.selector(img);
+      } else {
+        const possibleAttrs = this.selector
+          ? [this.selector].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.shouldDelete) {
+        if (this.shouldDelete === 'auto') {
+          removeClassesAndDataAttributes(img, 'lazy');
+        } else {
+          if (this.shouldDelete.startsWith('.')) {
+            img.classList.remove(this.shouldDelete.slice(1));
+          } else {
+            img.removeAttribute(this.shouldDelete);
+          }
+        }
+
+        if (img.src.includes('data:image')) {
+          result.img.src = '';
+        }
+
+        if (img.complete && img.naturalWidth > 0) {
+          return {};
+        }
+      }
+    }
+
+    return result;
+  }
+
+}

package/src/core/parsers/thumbs-parser.ts

@@ -0,0 +1,29 @@
+export class ThumbsParser {
+  public selector = '.thumb';
+  public strategy: 'default' | 'auto' = 'default';
+  public transform?: (thumb: HTMLElement) => void;
+
+  public static create(options: Partial<Pick<ThumbsParser, 'selector' | 'strategy' | 'transform'>> = {}, containerSelector: string) {
+    return Object.assign(new ThumbsParser(containerSelector), options);
+  }
+  constructor(public containerSelector: string) { }
+
+  public getThumbs(html: HTMLElement): HTMLElement[] {
+    if (!html) return [];
+    let thumbs: HTMLElement[];
+
+    if (this.strategy === 'auto') {
+      if (typeof this.selector !== 'string') return [];
+      const container = html.querySelector(this.containerSelector);
+      thumbs = [...(container?.children || [])] as HTMLElement[];
+    }
+
+    thumbs = Array.from(html.querySelectorAll<HTMLElement>(this.selector));
+
+    if (typeof this.transform === 'function') {
+      thumbs.forEach(this.transform);
+    }
+
+    return thumbs;
+  }
+}

package/src/core/rules/index.ts

@@ -2,174 +2,46 @@ import { JabronioGUI, JabronioStore, type JabroniTypes, setupScheme } from 'jabr
 import {
   getCommonParents,
   querySelectorLast,
-  querySelectorText,
-  removeClassesAndDataAttributes,
-  sanitizeStr,
-  timeToSeconds,
   waitForElementToDisappear,
 } from '../../utils';
-import { DataManager } from '../data-control';
-import type { DataSelectorFn } from '../data-control/data-filter';
-import { InfiniteScroller, type OffsetGenerator } from '../infinite-scroll/';
+import { DataManager, type DataSelectorFn } from '../data-handler';
+import { InfiniteScroller, type OffsetGenerator } from '../infinite-scroll';
 import { DefaultScheme, type SchemeOptions, StoreStateDefault } from '../jabroni-config';
-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;
-
+import {
+  getPaginationStrategy,
+  type PaginationStrategy,
+  ThumbDataParser,
+  ThumbImgParser,
+  ThumbsParser
+} from '../parsers';
+
+export class Rules {
   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: '' };
+  public thumb: Parameters<typeof ThumbDataParser.create>[0] = {};
+  public thumbDataParser: ThumbDataParser;
 
-    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;
-    }
+  public thumbImg: Parameters<typeof ThumbImgParser.create>[0] = {};
+  public thumbImgParser: ThumbImgParser;
 
-    this.getThumbDataCallback?.(thumb, thumbData);
+  public thumbs: Parameters<typeof ThumbsParser.create>[0] = {};
+  public thumbsParser: ThumbsParser;
 
-    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));
-    }
+  public containerSelector: string | (() => HTMLElement) = '.container';
+  public containerSelectorLast?: string;
 
-    if (this.customThumbDataSelectors) {
-      Object.entries(this.customThumbDataSelectors).forEach(([name, x]) => {
-        const data = getCustomThumbData(x.selector, x.type);
-        Object.assign(thumbData, { [name]: data });
-      });
+  get container() {
+    if (typeof this.containerSelectorLast === 'string') {
+      return querySelectorLast(document, this.containerSelectorLast) as HTMLElement;
     }
-
-    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 {};
-        }
-      }
+    if (typeof this.containerSelector === 'string') {
+      return document.querySelector<HTMLElement>(this.containerSelector) as HTMLElement;
     }
-
-    return result;
+    return this.containerSelector();
   }
 
-  public containerSelector: string | (() => HTMLElement) = '.container';
-  public containerSelectorLast?: string;
-
   public intersectionObservableSelector?: string;
 
   public get intersectionObservable() {
@@ -184,42 +56,11 @@ export class RulesGlobal {
       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 dataManager: DataManager;
+  public dataHomogenity: ConstructorParameters<typeof DataManager>[1];
   public customDataSelectorFns: (Record<string, DataSelectorFn<any>> | string)[] = [
     'filterInclude',
     'filterExclude',
@@ -229,6 +70,9 @@ export class RulesGlobal {
   public animatePreview?: (doc: HTMLElement) => void;
 
   public storeOptions?: JabroniTypes.StoreStateOptions;
+  public schemeOptions: SchemeOptions = [];
+  public store: JabronioStore;
+  public gui: JabronioGUI;
 
   private createStore() {
     const config = { ...StoreStateDefault, ...this.storeOptions };
@@ -236,8 +80,6 @@ export class RulesGlobal {
     return this.store;
   }
 
-  public schemeOptions: SchemeOptions = [];
-
   private createGui() {
     const scheme = setupScheme(
       this.schemeOptions as Parameters<typeof setupScheme>[0],
@@ -247,10 +89,7 @@ export class RulesGlobal {
     return this.gui;
   }
 
-  public store: JabronioStore;
-  public gui: JabronioGUI;
-  public dataManager: DataManager;
-
+  public customGenerator?: OffsetGenerator;
   public infiniteScroller?: InfiniteScroller;
   public getPaginationData?: InfiniteScroller['getPaginationData'];
 
@@ -268,7 +107,7 @@ export class RulesGlobal {
       this.dataManager?.parseData(this.container, this.container);
     }
     if (this.gropeStrategy === 'all-in-all') {
-      getCommonParents(this.getThumbs(document.body)).forEach((c) => {
+      getCommonParents(this.thumbsParser.getThumbs(document.body)).forEach((c) => {
         this.dataManager.parseData(c, c, true);
       });
     }
@@ -307,17 +146,6 @@ export class RulesGlobal {
     });
   }
 
-  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;
@@ -352,7 +180,7 @@ export class RulesGlobal {
 
     this.paginationStrategy = getPaginationStrategy(this.paginationStrategyOptions);
 
-    this.setupDataManager();
+    this.dataManager = new DataManager(this, this.dataHomogenity);
     this.setupStoreListeners();
 
     this.resetInfiniteScroller();
@@ -366,17 +194,21 @@ export class RulesGlobal {
     this.resetOn();
   }
 
-  constructor(options: Partial<RulesGlobal>) {
+  constructor(options: Partial<Rules>) {
     if (this.isEmbedded) throw Error('Embedded is not supported');
 
     Object.assign(this, options);
 
+    this.thumbDataParser = ThumbDataParser.create(this.thumb);
+    this.thumbImgParser = ThumbImgParser.create(this.thumbImg);
+    this.thumbsParser = ThumbsParser.create(this.thumbs, this.containerSelector as string);
+
     this.paginationStrategy = getPaginationStrategy(this.paginationStrategyOptions);
 
     this.store = this.createStore();
     this.gui = this.createGui();
 
-    this.dataManager = this.setupDataManager();
+    this.dataManager = new DataManager(this, this.dataHomogenity);
 
     this.reset();
     // console.log('data', this.dataManager.data.values().toArray());

package/src/userscripts/index.ts

@@ -1 +1 @@
-import './scripts/xvideos';
+import './scripts/pornhub';

package/src/userscripts/scripts/3hentai.ts

@@ -1,5 +1,5 @@
 import type { MonkeyUserScript } from 'vite-plugin-monkey';
-import { RulesGlobal } from '../../core';
+import { Rules } from '../../core';
 import { circularShift, OnHover, Tick } from '../../utils';
 
 export const meta: MonkeyUserScript = {
@@ -9,11 +9,19 @@ export const meta: MonkeyUserScript = {
   match: 'https://*.3hentai.net/*',
 };
 
-const rules = new RulesGlobal({
+const rules = new Rules({
   containerSelectorLast: '.listing-container',
-  thumbsSelector: '.doujin-col',
-  titleSelector: '.title',
-  getThumbImgDataStrategy: 'auto',
+  thumbs: {
+    selector: '.doujin-col'
+  },
+  thumb: {
+    selectors: {
+      title: '.title',
+    }
+  },
+  thumbImg: {
+    strategy: 'auto',
+  },
   gropeStrategy: 'all-in-all',
   customDataSelectorFns: ['filterInclude', 'filterExclude'],
   schemeOptions: ['Text Filter', 'Badge', 'Advanced'],
@@ -36,7 +44,7 @@ function animatePreview() {
       const t = e as HTMLImageElement;
       const origin = t.src;
       t.src = t.src.replace(/\w+\.\w+$/, '1t.jpg');
-      t.onerror = (_) => { t.src = origin };
+      t.onerror = (_) => tick.stop();
       tick.start(
         () => {
           t.src = rotate(t.src);

package/src/userscripts/scripts/camwhores.ts

@@ -1,13 +1,13 @@
 import { LSKDB } from 'lskdb';
 import type { MonkeyUserScript } from 'vite-plugin-monkey';
 import { GM_addStyle, unsafeWindow } from '$';
-import { getPaginationStrategy, InfiniteScroller, RulesGlobal } from '../../core';
+import { getPaginationStrategy, InfiniteScroller, Rules } from '../../core';
 import {
   circularShift,
   downloader,
   fetchHtml,
-  objectToFormData,
   OnHover,
+  objectToFormData,
   parseHtml,
   querySelectorLastNumber,
   querySelectorText,
@@ -39,22 +39,28 @@ const IS_COMMUNITY_LIST = /\/members\/$/.test(location.pathname);
 const IS_VIDEO_PAGE = /^(\/videos)?\/\d+\//.test(location.pathname);
 const IS_LOGGED_IN = document.cookie.includes('kt_member');
 
-const rules = new RulesGlobal({
+const rules = new Rules({
   containerSelector:
     '[id*="playlist"]:has(> .item .title),[id*="videos"]:has(> .item .title),form:has(>.item .title)',
   paginationStrategyOptions: {
     paginationSelector: '.pagination:not([id *= member])',
     overwritePaginationLast: IS_MEMBER_PAGE ? () => 1 : (x) => (x === 9 ? 9999 : x),
   },
-  getThumbImgDataAttrSelector: 'data-original',
-  getThumbImgDataStrategy: 'auto',
-  thumbsSelector:
-    '.list-videos .item, .playlist .item, .list-playlists > div > .item, .item:has(.title)',
-  gropeStrategy: 'all-in-all',
-  getThumbDataStrategy: 'auto-select',
-  customThumbDataSelectors: {
-    private: { type: 'boolean', selector: '[class*=private]' },
+  thumbs: {
+    selector:
+      '.list-videos .item, .playlist .item, .list-playlists > div > .item, .item:has(.title)'
   },
+  thumb: {
+    strategy: 'auto-select',
+    selectors: {
+      private: { type: 'boolean', selector: '[class*=private]' },
+    },
+  },
+  thumbImg: {
+    selector: 'data-original',
+    strategy: 'auto',
+  },
+  gropeStrategy: 'all-in-all',
   customDataSelectorFns: [
     'filterInclude',
     'filterExclude',
@@ -175,7 +181,7 @@ async function getMemberFriends(id: number | string) {
   const paginationStrategy = getPaginationStrategy({
     doc,
     url,
-    overwritePaginationLast: (x) => (x === 9 ? 999 : x),
+    overwritePaginationLast: (x: number) => (x === 9 ? 999 : x),
   });
 
   const gen = InfiniteScroller.generatorForPaginationStrategy(paginationStrategy);
@@ -301,7 +307,7 @@ async function acceptFriendRequest(id: number | string) {
 async function clearMessages() {
   const pages = InfiniteScroller.generatorForPaginationStrategy(
     getPaginationStrategy({
-      overwritePaginationLast: (x) => (x === 9 ? 999 : x),
+      overwritePaginationLast: (x: number) => (x === 9 ? 999 : x),
     }),
   );
 

package/src/userscripts/scripts/e-hentai.ts

@@ -1,5 +1,5 @@
 import type { MonkeyUserScript } from 'vite-plugin-monkey';
-import { RulesGlobal } from '../../core';
+import { Rules } from '../../core';
 import { fetchHtml } from '../../utils';
 
 export const meta: MonkeyUserScript = {
@@ -9,18 +9,24 @@ export const meta: MonkeyUserScript = {
   match: ['https://*.e-hentai.org/*'],
 };
 
-const rules = new RulesGlobal({
-  thumbsSelector: '.gl1t',
-  titleSelector: '.glname',
+const rules = new Rules({
+  thumbs: { selector: '.gl1t' },
+  thumb: {
+    selectors: {
+      title: '.glname'
+    }
+  },
+  thumbImg: {
+    selector: 'data-lazy-load',
+    strategy: 'auto',
+  },
   containerSelectorLast: '.itg.gld',
-  getThumbImgDataAttrSelector: 'data-lazy-load',
-  getThumbImgDataStrategy: 'auto',
   paginationStrategyOptions: createPaginationStrategyOptions(),
   customDataSelectorFns: ['filterInclude', 'filterExclude'],
   schemeOptions: ['Text Filter', 'Badge', 'Advanced'],
 });
 
-function createPaginationStrategyOptions(): RulesGlobal['paginationStrategyOptions'] {
+function createPaginationStrategyOptions(): Rules['paginationStrategyOptions'] {
   let nextLink: string;
 
   function getPaginationUrlGenerator() {

package/src/userscripts/scripts/ebalka.ts

@@ -1,5 +1,5 @@
 import type { MonkeyUserScript } from 'vite-plugin-monkey';
-import { RulesGlobal } from '../../core';
+import { Rules } from '../../core';
 import { exterminateVideo, OnHover, parseHtml } from '../../utils';
 
 export const meta: MonkeyUserScript = {
@@ -15,14 +15,20 @@ export const meta: MonkeyUserScript = {
   ],
 };
 
-const rules = new RulesGlobal({
+const rules = new Rules({
   containerSelectorLast: '.content__video',
   paginationStrategyOptions: {
     paginationSelector: '.pagination:not([id *= member])',
   },
-  thumbsSelector: '.card_video',
-  titleSelector: '.card__title',
-  durationSelector: '.card__spot > span:last-child',
+  thumbs: {
+    selector: '.card_video'
+  },
+  thumb: {
+    selectors: {
+      title: '.card__title',
+      duration: '.card__spot > span:last-child',
+    }
+  },
   animatePreview,
   schemeOptions: ['Text Filter', 'Badge', 'Duration Filter', 'Advanced'],
 });

package/src/userscripts/scripts/eporner.ts

@@ -1,6 +1,6 @@
 import type { MonkeyUserScript } from 'vite-plugin-monkey';
 import { unsafeWindow } from '$';
-import { RulesGlobal } from '../../core';
+import { Rules } from '../../core';
 import { OnHover } from '../../utils';
 
 export const meta: MonkeyUserScript = {
@@ -12,20 +12,26 @@ export const meta: MonkeyUserScript = {
 
 const show_video_prev = (unsafeWindow as any).show_video_prev;
 
-const rules = new RulesGlobal({
+const rules = new Rules({
   paginationStrategyOptions: {
     paginationSelector: '.numlist2',
   },
-  customThumbDataSelectors: {
-    quality: { type: 'number', selector: '[title="Quality"]' },
+  thumb: {
+    selectors: {
+      quality: { type: 'number', selector: '[title="Quality"]' },
+      title: 'a',
+      uploader: '[title="Uploader"]',
+      duration: '[title="Duration"]',
+    },
+  },
+  thumbImg: {
+    strategy: 'auto'
+    // getImgDataAttrDelete: 'auto',
+  },
+  thumbs: {
+    selector: 'div[id^=vf][data-id]',
   },
   containerSelectorLast: '#vidresults',
-  thumbsSelector: 'div[id^=vf][data-id]',
-  uploaderSelector: '[title="Uploader"]',
-  titleSelector: 'a',
-  durationSelector: '[title="Duration"]',
-  getThumbImgDataStrategy: 'auto',
-  getThumbImgDataAttrDelete: 'auto',
   customDataSelectorFns: [
     'filterInclude',
     'filterExclude',