pervert-monkey 1.0.9 → 1.0.11

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

@@ -0,0 +1,115 @@
+import {
+  querySelectorLast,
+  querySelectorText,
+  sanitizeStr,
+  timeToSeconds,
+} from '../../utils';
+
+type Primitive = string | number | boolean;
+type PrimitiveString = 'boolean' | 'string' | 'number' | 'duration';
+type ThumbData = Record<string, Primitive>;
+type ThumbDataSelector = {
+  name: string;
+  selector: string;
+  type: PrimitiveString;
+};
+type ThumbDataSelectorsRaw = Record<
+  string,
+  string | Pick<ThumbDataSelector, 'selector' | 'type'>
+>;
+
+export class ThumbDataParser {
+  private autoParseText(thumb: HTMLElement): ThumbData {
+    const title = sanitizeStr(thumb.innerText);
+    const duration = timeToSeconds(title.match(/\d+m|\d+:\d+/)?.[0] || '');
+    return { title, duration };
+  }
+
+  private preprocessCustomThumbDataSelectors() {
+    if (!this.selectors) return;
+    Object.entries(this.selectors).forEach(([key, value]) => {
+      if (typeof value === 'string') {
+        const defaultSelector = this.defaultThumbDataSelectors.find((e) => e.name === key);
+        if (!defaultSelector) {
+          this.thumbDataSelectors.push({ name: key, selector: value, type: 'string' });
+        } else {
+          defaultSelector.selector = value;
+          this.thumbDataSelectors.push(defaultSelector);
+        }
+      } else {
+        this.thumbDataSelectors.push({ name: key, ...value });
+      }
+    });
+  }
+
+  private thumbDataSelectors: ThumbDataSelector[] = [];
+  private readonly defaultThumbDataSelectors: ThumbDataSelector[] = [
+    { name: 'title', type: 'string', selector: '[class *= title],[title]' },
+    {
+      name: 'uploader',
+      type: 'string',
+      selector: '[class *= uploader], [class *= user], [class *= name]',
+    },
+    { name: 'duration', type: 'duration', selector: '[class *= duration]' },
+  ];
+
+  private getThumbDataWith(
+    thumb: HTMLElement,
+    { type, selector }: ThumbDataSelector,
+  ): Primitive {
+    if (type === 'boolean') {
+      return !!thumb.querySelector(selector);
+    }
+    if (type === 'string') {
+      return sanitizeStr(querySelectorLast(thumb, selector)?.innerText || '');
+    }
+    if (type === 'duration') {
+      return timeToSeconds(querySelectorText(thumb, selector));
+    }
+    return Number.parseInt(querySelectorText(thumb, selector));
+  }
+
+  constructor(
+    public strategy: 'manual' | 'auto-select' | 'auto-text' = 'manual',
+    public selectors: ThumbDataSelectorsRaw = {},
+    public callback?: (thumb: HTMLElement, thumbData: ThumbData) => void,
+    public stringsMeltInTitle = true,
+  ) {
+    this.preprocessCustomThumbDataSelectors();
+  }
+
+  public static create(
+    o: Partial<
+      Pick<ThumbDataParser, 'strategy' | 'selectors' | 'callback' | 'stringsMeltInTitle'>
+    > = {},
+  ) {
+    return new ThumbDataParser(o.strategy, o.selectors, o.callback, o.stringsMeltInTitle);
+  }
+
+  public getThumbData(thumb: HTMLElement): ThumbData {
+    if (this.strategy === 'auto-text') {
+      return this.autoParseText(thumb);
+    }
+
+    if (this.strategy === 'auto-select') {
+      this.thumbDataSelectors = this.defaultThumbDataSelectors;
+    }
+
+    const thumbData = Object.fromEntries(
+      this.thumbDataSelectors.map((s) => [s.name, this.getThumbDataWith(thumb, s)]),
+    );
+
+    if (this.stringsMeltInTitle) {
+      Object.entries(thumbData).forEach(([k, v]) => {
+        if (typeof v === 'string' && k !== 'title') {
+          thumbData.title = `${thumbData.title} ${k}:${v}`;
+          delete thumbData[k];
+        }
+      });
+    }
+
+    this.callback?.(thumb, thumbData);
+
+    return thumbData;
+  }
+}

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

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

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/eporner'

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'],
@@ -22,7 +30,7 @@ const rules = new RulesGlobal({
 
 function animatePreview() {
   const tick = new Tick(500, false);
-  const end = 999;
+  const end = 9999;
 
   function rotate(src: string) {
     return src.replace(/(\d+)(?=t\.jpg$)/,
@@ -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,27 @@ 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',
+  },
+  gropeStrategy: 'all-in-all',
   customDataSelectorFns: [
     'filterInclude',
     'filterExclude',
@@ -175,7 +180,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 +306,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),
     }),
   );