pervert-monkey 1.0.13 → 1.0.17

package/src/core/data-handler/data-filter.ts

@@ -1,139 +1,67 @@
-import type { StoreState } from 'jabroni-outfit';
 import { GM_addStyle } from 'vite-plugin-monkey/dist/client';
-import { RegexFilter } from '../../utils';
 import type { Rules } from '../rules';
-import type { DataElement } from './data-manager';
-
-export type DataSelectorFnShort = (e: DataElement, state: StoreState) => boolean;
-
-export type DataSelectorFnAdvanced<R> = {
-  handle: (el: DataElement, state: StoreState, $preDefineResult?: R) => boolean;
-  $preDefine?: (state: StoreState) => R;
-  deps?: string[];
-};
-
-export type DataSelectorFn<R> = DataSelectorFnAdvanced<R> | DataSelectorFnShort;
-
-interface DataFilterResult {
-  tag: string;
-  condition: boolean;
-}
-
-export type DataFilterFn = (v: DataElement) => DataFilterResult;
+import {
+  DataFilterFn,
+  type DataFilterFnFrom,
+  type DataFilterFnRendered,
+} from './data-filter-fn';
+import { defaultDataFilterFns } from './data-filter-fn-defaults';
 
 export class DataFilter {
-  public filters = new Map<string, () => DataFilterFn>();
+  public filters = new Map<string, () => DataFilterFnRendered>();
+  public filterMapping: Record<string, string> = {};
 
   constructor(private rules: Rules) {
-    this.registerFilters(rules.customDataSelectorFns);
-    this.applyCSSFilters();
+    this.registerFilters(rules.customDataFilterFns);
+    this.createCssFilters();
   }
 
-  public static isFiltered(el: HTMLElement): boolean {
-    return el.className.includes('filter-');
+  public static isFiltered(e: HTMLElement): boolean {
+    return e.className.includes(DataFilterFn.prefix);
   }
 
-  public applyCSSFilters(wrapper?: (cssRule: string) => string) {
+  public createCssFilters(wrapper?: (cssRule: string) => string) {
     this.filters.forEach((_, name) => {
-      const cssRule = `.filter-${name} { display: none !important; }`;
+      const className = DataFilterFn.setPrefix(name);
+      const cssRule = `.${className} { display: none !important; }`;
       GM_addStyle(wrapper ? wrapper(cssRule) : cssRule);
     });
   }
 
-  public customDataSelectorFns: Record<string, DataSelectorFn<any>> = {};
+  public customDataFilterFns: Record<string, DataFilterFnFrom<any>> = {};
 
-  public registerFilters(customFilters: (Record<string, DataSelectorFn<any>> | string)[]) {
+  public registerFilters(
+    customFilters: (Record<string, DataFilterFnFrom<any>> | string)[],
+  ) {
     customFilters.forEach((o) => {
-      if (typeof o === 'string') {
-        this.customDataSelectorFns[o] = DataFilter.customDataSelectorFnsDefault[o];
-        this.registerFilter(o);
-      } else {
-        const k = Object.keys(o)[0];
-        this.customDataSelectorFns[k] = o[k];
-        this.registerFilter(k);
-      }
-    });
-  }
+      const isStr = typeof o === 'string';
+      const k = isStr ? o : Object.keys(o)[0];
 
-  private customSelectorParser<T>(
-    name: string,
-    selector: DataSelectorFn<T>,
-  ): DataSelectorFnAdvanced<T> {
-    if ('handle' in selector) {
-      return selector as DataSelectorFnAdvanced<T>;
-    } else {
-      return { handle: selector, deps: [name] } as DataSelectorFnAdvanced<T>;
-    }
+      this.customDataFilterFns[k] = isStr ? defaultDataFilterFns[o] : o[k];
+      this.registerFilter(k);
+    });
   }
 
   public registerFilter(customSelectorName: string) {
-    const handler = this.customSelectorParser(
+    const dataFilterFn = DataFilterFn.from(
+      this.customDataFilterFns[customSelectorName],
       customSelectorName,
-      this.customDataSelectorFns[customSelectorName],
     );
-    const tag = `filter-${customSelectorName}`;
 
-    [customSelectorName, ...(handler.deps || [])]?.forEach((name) => {
+    dataFilterFn.deps.push(customSelectorName);
+
+    dataFilterFn.deps.forEach((name) => {
       Object.assign(this.filterMapping, { [name]: customSelectorName });
     });
 
-    const fn = (): DataFilterFn => {
-      const preDefined = handler.$preDefine?.(this.rules.store.state);
-
-      return (v: DataElement) => {
-        const condition = handler.handle(v, this.rules.store.state, preDefined);
-
-        return {
-          condition,
-          tag,
-        };
-      };
-    };
-
-    this.filters.set(customSelectorName, fn);
+    this.filters.set(customSelectorName, dataFilterFn.renderFn(this.rules.store.state));
   }
 
-  public filterMapping: Record<string, string> = {};
-
   public selectFilters(filters: { [key: string]: boolean }) {
     const selectedFilters = Object.keys(filters)
       .filter((k) => k in this.filterMapping)
       .map((k) => this.filterMapping[k])
-      .map((k) => this.filters.get(k) as () => DataFilterFn);
+      .map((k) => this.filters.get(k) as () => DataFilterFnRendered);
     return selectedFilters;
   }
-
-  static customDataSelectorFnsDefault: Record<string, DataSelectorFn<any>> = {
-    filterDuration: {
-      handle(el, state, notInRange) {
-        if (!state.filterDuration) return false;
-        return notInRange(el.duration);
-      },
-      $preDefine: (state) => {
-        const from = state.filterDurationFrom as number;
-        const to = state.filterDurationTo as number;
-        function notInRange(d: number): boolean {
-          return d < from || d > to;
-        }
-        return notInRange;
-      },
-      deps: ['filterDurationFrom', 'filterDurationTo'],
-    },
-    filterExclude: {
-      handle(el, state, searchFilter) {
-        if (!state.filterExclude) return false;
-        return !(searchFilter as RegexFilter).hasNone(el.title as string);
-      },
-      $preDefine: (state) => new RegexFilter(state.filterExcludeWords as string),
-      deps: ['filterExcludeWords'],
-    },
-    filterInclude: {
-      handle(el, state, searchFilter) {
-        if (!state.filterInclude) return false;
-        return !(searchFilter as RegexFilter).hasEvery(el.title as string);
-      },
-      $preDefine: (state) => new RegexFilter(state.filterIncludeWords as string),
-      deps: ['filterIncludeWords'],
-    },
-  };
 }

package/src/core/data-handler/data-manager.ts

@@ -3,7 +3,10 @@ import { checkHomogenity, LazyImgLoader } from '../../utils';
 import type { Rules } from '../rules';
 import { DataFilter } from './data-filter';
 
-export type DataElement = Record<string, string | number | boolean | HTMLElement>;
+export type DataElement = {
+  element: HTMLElement;
+  [key: string]: HTMLElement | string | number | boolean;
+};
 
 export class DataManager {
   public data = new Map<string, DataElement>();
@@ -14,7 +17,7 @@ export class DataManager {
 
   constructor(
     private rules: Rules,
-    private parentHomogenity?: Parameters<typeof checkHomogenity>[2],
+    private containerHomogenity?: Parameters<typeof checkHomogenity>[2],
   ) {
     this.dataFilter = new DataFilter(this.rules);
   }
@@ -29,29 +32,21 @@ export class DataManager {
     const iterator = this.data.values().drop(offset);
     let finished = false;
 
+    const updates: { e: HTMLElement; name: string; condition: boolean }[] = [];
+
     await new Promise((resolve) => {
       function runBatch(deadline: IdleDeadline) {
-        const updates: { e: HTMLElement; tag: string; condition: boolean }[] = [];
-
         while (deadline.timeRemaining() > 0) {
           const { value, done } = iterator.next();
           finished = !!done;
           if (done) break;
 
           for (const f of filtersToApply) {
-            const { tag, condition } = f()(value);
-            updates.push({ e: value.element as HTMLElement, tag, condition });
+            const { name, condition } = f()(value);
+            updates.push({ e: value.element as HTMLElement, name, condition });
           }
         }
 
-        if (updates.length > 0) {
-          requestAnimationFrame(() => {
-            updates.forEach((u) => {
-              u.e.classList.toggle(u.tag, u.condition);
-            });
-          });
-        }
-
         if (!finished) {
           requestIdleCallback(runBatch);
         } else {
@@ -61,8 +56,42 @@ export class DataManager {
 
       requestIdleCallback(runBatch);
     });
+
+    const parents = [...new Set(updates.map((u) => u.e.parentElement))].filter(
+      (_) => _ !== null,
+    );
+
+    requestAnimationFrame(() => {
+      const revertDisplayStyle = parents.map((p) => {
+        const display = p.style.display;
+        p.style.display = 'none';
+        this.layoutStylePaint(p);
+        p.style.willChange = 'contents';
+        return () => {
+          p.style.display = display;
+          requestAnimationFrame(() => {
+            p.style.willChange = 'auto';
+          });
+        };
+      });
+
+      updates.forEach((u) => {
+        u.e.classList.toggle(u.name, u.condition);
+      });
+
+      revertDisplayStyle.forEach((f) => {
+        f?.();
+      });
+    });
   };
 
+  public layoutStylePaintEnabled = false;
+
+  private layoutStylePaint(e: HTMLElement) {
+    if (!this.layoutStylePaintEnabled) return;
+    e.style.contain = 'layout style paint';
+  }
+
   public filterAll = async (offset?: number): Promise<void> => {
     const keys = Array.from(this.dataFilter.filters.keys());
     const filters = Object.fromEntries(
@@ -82,7 +111,7 @@ export class DataManager {
     const dataOffset = this.data.size;
     const fragment = document.createDocumentFragment();
     const parent = container || this.rules.container;
-    const homogenity = !!this.parentHomogenity;
+    const homogenity = !!this.containerHomogenity;
 
     for (const thumbElement of thumbs) {
       const url = this.rules.thumbDataParser.getUrl(thumbElement);
@@ -94,7 +123,7 @@ export class DataManager {
           !checkHomogenity(
             parent,
             thumbElement.parentElement as HTMLElement,
-            this.parentHomogenity as object,
+            this.containerHomogenity as object,
           ))
       ) {
         if (removeDuplicates) thumbElement.remove();
@@ -113,8 +142,19 @@ export class DataManager {
     }
 
     this.filterAll(dataOffset).then(() => {
+      if (!parent) return;
+      //
+      // THIS LINE BRAKES RENDERING, EVERYTHING DISAPPEARS
+      //
+      // this.layoutStylePaint(parent)
+      //
+      parent.style.willChange = 'contents';
       requestAnimationFrame(() => {
-        parent.appendChild(fragment);
+        // parent.style.contain = 'layout style paint';
+        parent?.appendChild(fragment);
+        requestAnimationFrame(() => {
+          parent.style.willChange = 'auto';
+        });
       });
     });
   };
@@ -122,23 +162,46 @@ export class DataManager {
   public sortBy<K extends keyof DataElement>(key: K, direction = true): void {
     if (this.data.size < 2) return;
 
-    let sorted: DataElement[] = this.data
+    const elements = this.data
       .values()
       .toArray()
-      .sort((a: DataElement, b: DataElement) => {
-        return (a[key] as number) - (b[key] as number);
-      });
+      .filter((e) => e.element.parentElement !== null)
+      .map((e) => e);
 
-    if (!direction) sorted = sorted.reverse();
-
-    const container = (sorted[0].element as HTMLElement).parentElement as HTMLElement;
+    const containers = new Set(elements.map((e) => e.element.parentElement as HTMLElement));
+    containers.forEach((c) => {
+      this.layoutStylePaint(c);
+      c.style.willChange = 'contents';
+    });
 
-    container.style.visibility = 'hidden';
+    const elementsByContainers = new Map<HTMLElement, DataElement[]>();
+    containers.forEach((c) => {
+      elementsByContainers.set(c, []);
+    });
 
-    sorted.forEach((s) => {
-      container.append(s.element as HTMLElement);
+    elements.forEach((e) => {
+      const parent = e.element.parentElement as HTMLElement;
+      const container = elementsByContainers.get(parent);
+      container?.push(e);
     });
 
-    container.style.visibility = 'visible';
+    const dir = direction ? -1 : 1;
+
+    for (const [container, items] of elementsByContainers) {
+      items.sort((a, b) => ((a[key] as number) - (b[key] as number)) * dir);
+      const domNodes = items.map((e) => e.element);
+
+      const display = container.style.display;
+      container.style.display = 'none';
+
+      container.replaceChildren(...domNodes);
+
+      requestAnimationFrame(() => {
+        container.style.display = display;
+        requestAnimationFrame(() => {
+          container.style.willChange = 'auto';
+        });
+      });
+    }
   }
 }

package/src/core/jabroni-config/default-scheme.ts

@@ -2,7 +2,7 @@ import type { JabroniTypes, SchemeInput, setupScheme } from 'jabroni-outfit';
 
 export const DefaultScheme = [
   {
-    title: 'Text Filter',
+    title: 'Title Filter',
     collapsed: true,
     content: [
       { filterExclude: false, label: 'exclude' },
@@ -21,6 +21,26 @@ export const DefaultScheme = [
       },
     ],
   },
+  {
+    title: 'Uploader Filter',
+    collapsed: true,
+    content: [
+      { filterUploaderExclude: false, label: 'exclude' },
+      {
+        filterUploaderExcludeWords: '',
+        label: 'keywords',
+        watch: 'filterUploaderExclude',
+        placeholder: 'word, f:full_word, r:RegEx...',
+      },
+      { filterUploaderInclude: false, label: 'include' },
+      {
+        filterUploaderIncludeWords: '',
+        label: 'keywords',
+        watch: 'filterUploaderInclude',
+        placeholder: 'word, f:full_word, r:RegEx...',
+      },
+    ],
+  },
   {
     title: 'Duration Filter',
     collapsed: true,
@@ -42,6 +62,7 @@ export const DefaultScheme = [
   },
   {
     title: 'Sort By',
+    collapsed: true,
     content: [
       {
         'sort by views': () => {},
@@ -51,14 +72,40 @@ export const DefaultScheme = [
       },
     ],
   },
+  {
+    title: 'Sort By Duration',
+    collapsed: true,
+    content: [
+      {
+        'sort by duration': () => {},
+      },
+    ],
+  },
+  {
+    title: 'Sort By Views',
+    collapsed: true,
+    content: [
+      {
+        'sort by views': () => {},
+      },
+    ],
+  },
   {
     title: 'Privacy Filter',
+    collapsed: true,
     content: [
       { filterPrivate: false, label: 'private' },
       { filterPublic: false, label: 'public' },
       { 'check access 🔓': () => {} },
     ],
   },
+  {
+    title: 'HD Filter',
+    content: [
+      { filterHD: false, label: 'hd' },
+      { filterNonHD: false, label: 'non-hd' },
+    ],
+  },
   {
     title: 'Advanced',
     collapsed: true,
@@ -79,6 +126,9 @@ export const DefaultScheme = [
         writeHistory: false,
         label: 'write history',
       },
+      {
+        reset: () => { localStorage.removeItem('state_acephale'); }
+      }
     ],
   },
   {
@@ -92,7 +142,6 @@ export const DefaultScheme = [
   },
 ] as const satisfies SchemeInput;
 
-export type SchemeOptions = (
-  | Parameters<typeof setupScheme>[0][0]
-  | JabroniTypes.ExtractValuesByKey<typeof DefaultScheme, 'title'>
-)[];
+export type SchemeKeys = JabroniTypes.ExtractValuesByKey<typeof DefaultScheme, 'title'>;
+
+export type SchemeOptions = (Parameters<typeof setupScheme>[0][0] | SchemeKeys)[];

package/src/core/jabroni-config/index.ts

@@ -1,3 +1,4 @@
 export * from './default-scheme';
 export * from './default-store';
 export * from './jabroni-gui-controller';
+export * from './scheme-selectors-mapping';

package/src/core/jabroni-config/jabroni-gui-controller.ts

@@ -51,7 +51,7 @@ export class JabronioGuiController {
 
   private setupStoreListeners() {
     this.directionalEventObservable$?.subscribe((e) => {
-      this.eventsMap[e.type](e.direction);
+      this.eventsMap[e.type]?.(e.direction);
     });
 
     this.store.stateSubject.pipe(takeUntil(this.destroy$)).subscribe((a) => {

package/src/core/jabroni-config/scheme-selectors-mapping.ts

@@ -0,0 +1,12 @@
+import { defaultDataFilterFns } from '../data-handler/data-filter-fn-defaults';
+import { DefaultScheme, type SchemeKeys } from './default-scheme';
+
+export function getSelectorFnsFromScheme(xs: SchemeKeys[]) {
+  const keys = xs.flatMap((s) => {
+    const schemeBlock = DefaultScheme.find((e) => e.title === s);
+    if (!schemeBlock) return [];
+    return schemeBlock.content.flatMap((c) => Object.keys(c));
+  });
+
+  return keys.filter((k) => k in defaultDataFilterFns);
+}

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

@@ -7,13 +7,15 @@ import {
 } from '../../utils';
 
 type Primitive = string | number | boolean;
-type PrimitiveString = 'boolean' | 'string' | 'number' | 'float' | 'duration';
+
 type ThumbData = Record<string, Primitive>;
+
 type ThumbDataSelector = {
   name: string;
   selector: string;
-  type: PrimitiveString;
+  type: 'boolean' | 'string' | 'number' | 'float' | 'duration';
 };
+
 type ThumbDataSelectorsRaw = Record<
   string,
   string | Pick<ThumbDataSelector, 'selector' | 'type'>
@@ -21,8 +23,13 @@ type ThumbDataSelectorsRaw = Record<
 
 export class ThumbDataParser {
   private autoParseText(thumb: HTMLElement): ThumbData {
-    const title = sanitizeStr(thumb.innerText);
-    const duration = timeToSeconds(title.match(/\d+m|\d+:\d+/)?.[0] || '');
+    let title = sanitizeStr(thumb.innerText);
+
+    const durationStr = title.match(/(\d+:\d+:?\d+?)|\d+m/)?.[0] || '';
+    const duration = timeToSeconds(durationStr);
+
+    title = title.replaceAll(durationStr, '');
+
     return { title, duration };
   }
 
@@ -56,6 +63,7 @@ export class ThumbDataParser {
       selector: '[class *= uploader], [class *= user], [class *= name]',
     },
     { name: 'duration', type: 'duration', selector: '[class *= duration]' },
+    // { name: 'views', type: 'float', selector: '[class *= view]' },
   ];
 
   private getThumbDataWith(
@@ -82,17 +90,14 @@ export class ThumbDataParser {
     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'>
-    > = {},
+    o: Partial<Pick<ThumbDataParser, 'strategy' | 'selectors' | 'callback'>> = {},
   ) {
-    return new ThumbDataParser(o.strategy, o.selectors, o.callback, o.stringsMeltInTitle);
+    return new ThumbDataParser(o.strategy, o.selectors, o.callback);
   }
 
   public getThumbData(thumb: HTMLElement): ThumbData {
@@ -101,22 +106,13 @@ export class ThumbDataParser {
     }
 
     if (this.strategy === 'auto-select') {
-      this.thumbDataSelectors = this.defaultThumbDataSelectors;
+      this.thumbDataSelectors.push(...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/rules/index.ts

@@ -4,10 +4,12 @@ import {
   querySelectorLast,
   waitForElementToDisappear,
 } from '../../utils';
-import { DataManager, type DataSelectorFn } from '../data-handler';
+import { DataManager } from '../data-handler';
+import type { DataFilterFnFrom } from '../data-handler/data-filter-fn';
 import { InfiniteScroller, type OffsetGenerator } from '../infinite-scroll';
 import {
   DefaultScheme,
+  getSelectorFnsFromScheme,
   JabronioGuiController,
   type SchemeOptions,
   StoreStateDefault,
@@ -61,12 +63,15 @@ export class Rules {
   public paginationStrategy: PaginationStrategy;
 
   public dataManager: DataManager;
-  public dataHomogenity: ConstructorParameters<typeof DataManager>[1];
-  public customDataSelectorFns: (Record<string, DataSelectorFn<any>> | string)[] = [
-    'filterInclude',
-    'filterExclude',
-    'filterDuration',
-  ];
+  public containerHomogenity: ConstructorParameters<typeof DataManager>[1];
+
+  public customDataFilterFns: (Record<string, DataFilterFnFrom<any>> | string)[] = [];
+  private hookDataFilterFns() {
+    const defaultFilterFns = getSelectorFnsFromScheme(
+      this.schemeOptions.filter((s) => typeof s === 'string'),
+    );
+    this.customDataFilterFns.push(...defaultFilterFns);
+  }
 
   public animatePreview?: (doc: HTMLElement) => void;
 
@@ -151,7 +156,7 @@ export class Rules {
 
     this.paginationStrategy = getPaginationStrategy(this.paginationStrategyOptions);
 
-    this.dataManager = new DataManager(this, this.dataHomogenity);
+    this.dataManager = new DataManager(this, this.containerHomogenity);
 
     this.inputController.dispose();
     this.inputController = new JabronioGuiController(this.store, this.dataManager);
@@ -181,7 +186,8 @@ export class Rules {
     this.store = this.createStore();
     this.gui = this.createGui();
 
-    this.dataManager = new DataManager(this, this.dataHomogenity);
+    this.hookDataFilterFns();
+    this.dataManager = new DataManager(this, this.containerHomogenity);
     this.inputController = new JabronioGuiController(this.store, this.dataManager);
 
     this.reset();

package/src/userscripts/index.ts

@@ -1 +1 @@
-import './scripts/motherless'
+import './scripts/ebalka';

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

@@ -4,8 +4,8 @@ import { circularShift, OnHover, Tick } from '../../utils';
 
 export const meta: MonkeyUserScript = {
   name: '3Hentai PervertMonkey',
-  version: '1.0.4',
-  description: 'Infinite scroll [optional], Filter by Title',
+  version: '1.0.7',
+  description: 'Infinite scroll [optional], Filter by Title, thumb preview',
   match: 'https://*.3hentai.net/*',
 };
 
@@ -23,8 +23,7 @@ const rules = new Rules({
     strategy: 'auto',
   },
   gropeStrategy: 'all-in-all',
-  customDataSelectorFns: ['filterInclude', 'filterExclude'],
-  schemeOptions: ['Text Filter', 'Badge', 'Advanced'],
+  schemeOptions: ['Title Filter', 'Badge', 'Advanced'],
   animatePreview,
 });
 

package/src/userscripts/scripts/camgirlfinder.ts

@@ -2,7 +2,7 @@ import type { MonkeyUserScript } from 'vite-plugin-monkey';
 
 export const meta: MonkeyUserScript = {
   name: 'CamGirlFinder PervertMonkey',
-  version: '1.6.2',
+  version: '1.6.6',
   description:
     'Adds model links for CamWhores, webcamrecordings, recu.me, camvideos, privat-zapisi',
   match: ['https://camgirlfinder.net/*'],