pervert-monkey 1.0.0

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "pervert-monkey",
+  "description": "daddy told us not to be ashamed of our userscripts",
+  "version": "1.0.0",
+  "license": "MIT",
+  "keywords": [
+    "userscript",
+    "tampermonkey",
+    "violentmonkey",
+    "sleazy-fork"
+  ],
+  "author": "ViolentOrangutan atm.mormon@protonmail.com (https://github.com/smartacephale)",
+  "homepage": "https://github.com/smartacephale/sleazy-fork#readme",
+  "type": "module",
+  "main": "dist/perverpervertmonkey.core.umd.js",
+  "module": "dist/perverpervertmonkey.core.es.js",
+  "types": "dist/perverpervertmonkey.core.es.d.ts",
+  "repository": "github:smartacephale/sleazy-fork",
+  "bugs": {
+    "url": "https://github.com/smartacephale/sleazy-fork/issues",
+    "email": "atm.mormon@protonmail.com"
+  },
+  "browser": "dist/perverpervertmonkey.core.es.js",
+  "unpkg": "dist/perverpervertmonkey.core.es.js",
+  "exports": {
+    ".": {
+      "types": "./dist/perverpervertmonkey.core.es.d.ts",
+      "import": "./dist/perverpervertmonkey.core.es.js",
+      "require": "./dist/perverpervertmonkey.core.umd.js"
+    }
+  },
+  "files": [
+    "src/**/*",
+    "dist/**/*"
+  ],
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc && vite build",
+    "build:userscripts": "node vite.build.ts"
+  },
+  "devDependencies": {
+    "@types/node": "^25.2.3",
+    "jabroni-outfit": "^2.1.1",
+    "typescript": "^5.9.3",
+    "vite": "^6.4.1",
+    "vite-plugin-dts": "^4.0.3"
+  },
+  "dependencies": {
+    "ix": "^7.0.0",
+    "lskdb": "^1.0.2",
+    "urlpattern-polyfill": "^10.1.0",
+    "vite-plugin-monkey": "^7.1.9"
+  }
+}

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

@@ -0,0 +1,143 @@
+import type { StoreState } from 'jabroni-outfit';
+import { GM_addStyle } from '$';
+import { RegexFilter } from '../../utils/strings/regexes';
+import type { RulesGlobal } 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;
+
+export class DataFilter {
+  public filters = new Map<string, () => DataFilterFn>();
+
+  constructor(private rules: RulesGlobal) {
+    this.registerFilters(rules.customDataSelectorFns);
+    this.applyCSSFilters();
+  }
+
+  public static isFiltered(el: HTMLElement): boolean {
+    return el.className.includes('filter-');
+  }
+
+  public applyCSSFilters(wrapper?: (cssRule: string) => string) {
+    this.filters.forEach((_, name) => {
+      const cssRule = `.filter-${name} { display: none !important; }`;
+      // this.appliedStyle = GM_addStyle();
+      if (wrapper) {
+        GM_addStyle(wrapper(cssRule));
+      } else {
+        GM_addStyle(cssRule);
+      }
+    });
+  }
+
+  public customDataSelectorFns: Record<string, DataSelectorFn<any>> = {};
+
+  public registerFilters(customFilters: (Record<string, DataSelectorFn<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);
+      }
+    });
+  }
+
+  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>;
+    }
+  }
+
+  public registerFilter(customSelectorName: string) {
+    const handler = this.customSelectorParser(
+      customSelectorName,
+      this.customDataSelectorFns[customSelectorName],
+    );
+    const tag = `filter-${customSelectorName}`;
+
+    [customSelectorName, ...(handler.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);
+  }
+
+  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);
+    return selectedFilters;
+  }
+
+  static customDataSelectorFnsDefault: Record<string, DataSelectorFn<any>> = {
+    filterDuration: {
+      handle(el, state, notInRange) {
+        return (state.filterDuration as boolean) && notInRange(el.duration);
+      },
+      $preDefine: (state) => {
+        const from = state.filterDurationFrom as number;
+        const to = state.filterDurationTo as number;
+        function notInRange(d: number) {
+          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-control/data-manager.ts

@@ -0,0 +1,144 @@
+import type { StoreState } from 'jabroni-outfit';
+import { checkHomogenity } from '../../utils/dom';
+import { LazyImgLoader } from '../../utils/observers';
+import type { RulesGlobal } from '../rules';
+import { DataFilter } from './data-filter';
+
+export type DataElement = Record<string, string | number | boolean | HTMLElement>;
+
+export class DataManager {
+  public data = new Map<string, DataElement>();
+  private lazyImgLoader = new LazyImgLoader(
+    (target: Element) => !DataFilter.isFiltered(target as HTMLElement),
+  );
+  public dataFilter: DataFilter;
+
+  constructor(private rules: RulesGlobal) {
+    this.dataFilter = new DataFilter(this.rules);
+  }
+
+  public applyFilters = async (
+    filters: Record<string, boolean> = {},
+    offset = 0,
+  ): Promise<void> => {
+    const filtersToApply = this.dataFilter.selectFilters(filters);
+    if (filtersToApply.length === 0) return;
+
+    const iterator = this.data.values().drop(offset);
+    let finished = false;
+
+    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 });
+          }
+        }
+
+        if (updates.length > 0) {
+          requestAnimationFrame(() => {
+            updates.forEach((u) => {
+              u.e.classList.toggle(u.tag, u.condition);
+            });
+          });
+        }
+
+        if (!finished) {
+          requestIdleCallback(runBatch);
+        } else {
+          resolve(true);
+        }
+      }
+
+      requestIdleCallback(runBatch);
+    });
+  };
+
+  public filterAll = async (offset?: number): Promise<void> => {
+    const keys = Array.from(this.dataFilter.filters.keys());
+    const filters = Object.fromEntries(
+      keys.map((k) => [k, this.rules.store.state[k as keyof StoreState]]),
+    ) as Record<string, boolean>;
+
+    await this.applyFilters(filters, offset);
+  };
+
+  public parseDataParentHomogenity?: Parameters<typeof checkHomogenity>[2];
+
+  public parseData = (
+    html: HTMLElement,
+    container?: HTMLElement,
+    removeDuplicates = false,
+    shouldLazify = true,
+  ): void => {
+    const thumbs = this.rules.getThumbs(html);
+    const dataOffset = this.data.size;
+    const fragment = document.createDocumentFragment();
+    const parent = container || this.rules.container;
+    const homogenity = !!this.parseDataParentHomogenity;
+
+    for (const thumbElement of thumbs) {
+      const url = this.rules.getThumbUrl(thumbElement);
+      if (
+        !url ||
+        this.data.has(url) ||
+        (parent !== container && parent?.contains(thumbElement)) ||
+        (homogenity &&
+          !checkHomogenity(
+            parent,
+            thumbElement.parentElement as HTMLElement,
+            this.parseDataParentHomogenity as object,
+          ))
+      ) {
+        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);
+    }
+
+    this.filterAll(dataOffset).then(() => {
+      requestAnimationFrame(() => {
+        parent.appendChild(fragment);
+      });
+    });
+  };
+
+  public sortBy<K extends keyof DataElement>(key: K, direction = true): void {
+    if (this.data.size < 2) return;
+
+    let sorted: DataElement[] = this.data
+      .values()
+      .toArray()
+      .sort((a: DataElement, b: DataElement) => {
+        return (a[key] as number) - (b[key] as number);
+      });
+
+    if (!direction) sorted = sorted.reverse();
+
+    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/core/data-control/index.ts

@@ -0,0 +1,2 @@
+export { DataFilter } from './data-filter';
+export { DataManager } from './data-manager';

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

@@ -0,0 +1,143 @@
+import { wait } from '../../utils/async';
+import { fetchHtml } from '../../utils/fetch';
+import { Observer } from '../../utils/observers';
+import type { PaginationStrategy } from '../pagination-parsing/pagination-strategies';
+import type { RulesGlobal } from '../rules';
+
+type InfiniteScrollerOptions = Pick<InfiniteScroller, 'rules'> & Partial<InfiniteScroller>;
+type GeneratorResult = { url: string; offset: number };
+export type OffsetGenerator<T = GeneratorResult> = Generator<T> | AsyncGenerator<T>;
+
+export class InfiniteScroller {
+  public enabled = true;
+  public paginationOffset = 1;
+  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);
+
+    if (this.rules.getPaginationData) {
+      this.getPaginationData = this.rules.getPaginationData;
+    }
+
+    this.paginationGenerator =
+      this.rules.customGenerator ||
+      InfiniteScroller.generatorForPaginationStrategy(this.rules.paginationStrategy);
+    this.setObserver(this.rules.observable);
+    this.setAutoScroll();
+  }
+
+  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.rules.store.state.delay as number,
+    );
+    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);
+    });
+  }
+
+  private setAutoScroll() {
+    const autoScrollWrapper = async () => {
+      if (this.rules.store.state.autoScroll) {
+        await wait(this.rules.store.state.delay as number);
+        await this.generatorConsumer();
+        await autoScrollWrapper();
+      }
+    };
+
+    autoScrollWrapper();
+
+    this.rules.store.stateSubject.subscribe((type) => {
+      if (type?.autoScroll) {
+        autoScrollWrapper();
+      }
+    });
+  }
+
+  generatorConsumer = async () => {
+    if (!this.enabled) return false;
+    const {
+      value: { url, offset },
+      done,
+    } = await this.paginationGenerator.next();
+    if (!done && url) {
+      await this.doScroll(url, offset);
+    }
+    return !done;
+  };
+
+  // consume api strategy
+  private async getPaginationData(url: string): Promise<HTMLElement> {
+    return await fetchHtml(url);
+  }
+
+  async doScroll(url: string, offset: number) {
+    const nextPageHtml = await this.getPaginationData(url);
+    const prevScrollPos = document.documentElement.scrollTop;
+    this.paginationOffset = Math.max(this.paginationOffset, offset);
+    this.parseData?.(nextPageHtml);
+    this._onScroll();
+    window.scrollTo(0, prevScrollPos);
+    if (this.rules.store.state.writeHistory) {
+      history.replaceState({}, '', url);
+    }
+  }
+
+  static async *generatorForPaginationStrategy(
+    pstrategy: PaginationStrategy,
+  ): OffsetGenerator {
+    const _offset = pstrategy.getPaginationOffset();
+    const end = pstrategy.getPaginationLast();
+    const urlGenerator = pstrategy.getPaginationUrlGenerator();
+
+    for (let offset = _offset; offset <= end; offset++) {
+      const url = await urlGenerator(offset);
+      yield { url, offset };
+    }
+  }
+
+  static create(rules: RulesGlobal) {
+    const enabled = rules.store.state.infiniteScrollEnabled as boolean;
+
+    rules.store.state.$paginationLast = rules.paginationStrategy.getPaginationLast();
+
+    const infiniteScroller = new InfiniteScroller({
+      enabled,
+      parseData: rules.dataManager.parseData,
+      rules,
+    }).onScroll(({ paginationOffset }) => {
+      rules.store.state.$paginationOffset = paginationOffset;
+    }, true);
+
+    rules.store.stateSubject.subscribe(() => {
+      infiniteScroller.enabled = rules.store.state.infiniteScrollEnabled as boolean;
+    });
+
+    return infiniteScroller;
+  }
+}

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

@@ -0,0 +1,97 @@
+import type { JabroniTypes, SchemeInput, setupScheme } from 'jabroni-outfit';
+
+export const DefaultScheme = [
+  {
+    title: 'Text Filter',
+    collapsed: true,
+    content: [
+      { filterExclude: false, label: 'exclude' },
+      {
+        filterExcludeWords: '',
+        label: 'keywords',
+        watch: 'filterExclude',
+        placeholder: 'word, f:full_word, r:RegEx...',
+      },
+      { filterInclude: false, label: 'include' },
+      {
+        filterIncludeWords: '',
+        label: 'keywords',
+        watch: 'filterInclude',
+        placeholder: 'word, f:full_word, r:RegEx...',
+      },
+    ],
+  },
+  {
+    title: 'Duration Filter',
+    collapsed: true,
+    content: [
+      { filterDuration: false, label: 'enable' },
+      {
+        filterDurationFrom: 0,
+        watch: 'filterDuration',
+        label: 'from',
+        type: 'time',
+      },
+      {
+        filterDurationTo: 600,
+        watch: 'filterDuration',
+        label: 'to',
+        type: 'time',
+      },
+    ],
+  },
+  {
+    title: 'Sort By',
+    content: [
+      {
+        'sort by views': () => {},
+      },
+      {
+        'sort by duration': () => {},
+      },
+    ],
+  },
+  {
+    title: 'Privacy Filter',
+    content: [
+      { filterPrivate: false, label: 'private' },
+      { filterPublic: false, label: 'public' },
+      { 'check access 🔓': () => {} },
+    ],
+  },
+  {
+    title: 'Advanced',
+    content: [
+      {
+        infiniteScrollEnabled: true,
+        label: 'infinite scroll',
+      },
+      {
+        autoScroll: false,
+        label: 'auto scroll',
+      },
+      {
+        delay: 250,
+        label: 'scroll delay',
+      },
+      {
+        writeHistory: false,
+        label: 'write history',
+      },
+    ],
+  },
+  {
+    title: 'Badge',
+    content: [
+      {
+        text: 'return `${state.$paginationOffset}/${state.$paginationLast}`',
+        vif: 'return state.$paginationLast > 1',
+      },
+    ],
+  },
+] as const satisfies SchemeInput;
+
+export type SchemeOptions = (
+  | Parameters<typeof setupScheme>[0][0]
+  | JabroniTypes.ExtractValuesByKey<typeof DefaultScheme, 'title'>
+)[];

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

@@ -0,0 +1,9 @@
+import type { JabroniTypes } from 'jabroni-outfit';
+
+export const StoreStateDefault: JabroniTypes.StoreStateOptions = {
+  enabled: true,
+  collapsed: false,
+  darkmode: true,
+  $paginationLast: 1,
+  $paginationOffset: 1,
+};

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

@@ -0,0 +1,55 @@
+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;
+  }
+
+  if (typeof options.getPaginationUrlGenerator === 'function') {
+    // console.log(PaginationStrategy.name);
+    return new PaginationStrategy(options);
+  }
+
+  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({ [PaginationStrategyConstructor.name]: paginationStrategy });
+
+  return paginationStrategy;
+}

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

@@ -0,0 +1,44 @@
+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 overwritePaginationLast?: (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() {
+    if (this.overwritePaginationLast) return this.overwritePaginationLast(1);
+    return 1;
+  }
+
+  getPaginationUrlGenerator(): (offset: number) => string | Promise<string> {
+    return (_: number) => this.url.href;
+  }
+}