billy-herrington-utils 1.5.9 → 2.0.0

package/dist/index.d.ts

@@ -1,3 +1,9 @@
+import { JabronioGUI } from 'jabroni-outfit';
+import { JabronioStore } from 'jabroni-outfit';
+import { JabroniTypes } from 'jabroni-outfit';
+import { setupScheme } from 'jabroni-outfit';
+import { StoreState } from 'jabroni-outfit';
+
 export declare class AsyncPool {
     private max;
     private pool;
@@ -24,40 +30,29 @@ export declare function circularShift(n: number, c?: number, s?: number): number
 
 export declare function computeAsyncOneAtTime(iterable: Iterable<() => Promise<void>>): Promise<void[]>;
 
-export declare function copyAttributes(target: HTMLElement | Element, source: HTMLElement | Element): void;
-
-export declare function createInfiniteScroller(store: JabroniStore, parseData: (document: HTMLElement) => void, rules: IRules_2): InfiniteScroller;
-
-declare interface DataFilterState {
-    filterPublic: boolean;
-    filterPrivate: boolean;
-    filterHD: boolean;
-    filterDuration: boolean;
-    filterDurationFrom: number;
-    filterDurationTo: number;
-    filterExclude: boolean;
-    filterExcludeWords: string;
-    filterInclude: boolean;
-    filterIncludeWords: string;
-}
+export declare function copyAttributes(target: HTMLElement, source: HTMLElement): void;
+
+declare type CustomSelector<R> = {
+    handle: (el: DataElement, state: StoreState, $preDefineResult?: R) => boolean;
+    $preDefine?: (state: StoreState) => R;
+};
+
+declare type DataElement = Record<string, string | number | boolean | HTMLElement>;
 
 export declare class DataManager {
     private rules;
     private state;
     private data;
     private lazyImgLoader;
-    dataFilters: {
-        [key: string]: () => FilterFunction;
-    };
-    constructor(rules: IRules, state: DataFilterState);
-    static filterDSLToRegex(str: string): RegExp[];
+    private dataFilter;
+    constructor(rules: RulesGlobal, state: StoreState);
     isFiltered(el: HTMLElement): boolean;
-    applyFilters: (filters: {
+    applyFilters: (filters?: {
         [key: string]: boolean;
     }, offset?: number) => void;
     filterAll: (offset?: number) => void;
     parseData: (html: HTMLElement, container?: HTMLElement, removeDuplicates?: boolean, shouldLazify?: boolean) => void;
-    sort(propName: string): void;
+    sortBy<K extends keyof DataElement>(key: K): void;
 }
 
 export declare function downloader(options?: {
@@ -73,117 +68,70 @@ export declare const fetchHtml: (url: string) => Promise<HTMLElement>;
 
 export declare const fetchText: (url: string) => Promise<string>;
 
-export declare function fetchWith(url: string, options?: Record<string, boolean>): Promise<string | HTMLElement>;
+export declare function fetchWith(url: string, options?: {
+    html?: boolean;
+    mobile?: boolean;
+}): Promise<string | HTMLElement>;
 
-declare type FilterFunction = (v: FilterInput) => FilterResult;
+export declare function findNextSibling(el: HTMLElement): Element | null;
 
-declare type FilterInput = Record<string, string | number | boolean | HTMLElement>;
-
-declare interface FilterResult {
-    tag: string;
-    condition: boolean;
-}
-
-export declare function findNextSibling(el: HTMLElement | Element): Element | null;
-
-declare interface GeneratorResult {
+declare type GeneratorResult = {
     url: string;
     offset: number;
-}
+};
 
-export declare function getAllUniqueParents(elements: HTMLCollection): Array<HTMLElement | Element>;
+export declare function getAllUniqueParents(elements: HTMLCollection | HTMLElement[]): HTMLElement[];
 
-export declare function getPaginationStrategy(options: IPaginationStrategy): PaginationStrategy;
-
-declare interface IInfiniteScroller {
-    delay?: number;
-    enabled?: boolean;
-    writeHistory?: boolean;
-    paginationOffset: number;
-    paginationLast: number;
-    paginationElement: HTMLElement;
-    paginationUrlGenerator: (offset: number) => string;
-    parseData: (document: HTMLElement) => void;
-    intersectionObservable?: HTMLElement;
-    alternativeGenerator?: () => OffsetGenerator;
-}
+export declare function getPaginationStrategy(options: Partial<PaginationStrategy>): PaginationStrategy;
 
 export declare class InfiniteScroller {
-    paginationGenerator: OffsetGenerator;
     enabled: boolean;
     delay: number;
     paginationOffset: number;
-    paginationLast: number;
     writeHistory: boolean;
-    private parseData;
-    constructor({ enabled, delay, writeHistory, paginationOffset, paginationLast, paginationElement, paginationUrlGenerator, parseData, alternativeGenerator, intersectionObservable, }: IInfiniteScroller);
+    parseData?: (document: HTMLElement) => void;
+    rules: RulesGlobal;
+    private observer?;
+    private paginationGenerator;
+    constructor(options: InfiniteScrollerOptions);
+    dispose(): void;
+    setObserver(observable: HTMLElement): this;
     private onScrollCBs;
     onScroll(callback: (scroller: InfiniteScroller) => void, initCall?: boolean): this;
     private _onScroll;
     generatorConsumer: () => Promise<boolean>;
-    static createPaginationGenerator(currentPage: number, totalPages: number, generateURL: (offset: number) => string): OffsetGenerator;
-}
-
-declare interface IPaginationStrategy {
-    url?: URL | Location | string;
-    doc?: Document | HTMLElement;
-    paginationSelector?: string;
-    fixPaginationLast?: (n: number, offset?: number) => number;
-    pathnameSelector?: RegExp;
-    searchParamSelector?: string;
-    offsetMin?: number;
-}
-
-declare interface IRules {
-    getThumbs: (html: HTMLElement) => HTMLElement[];
-    getThumbUrl: (thumbElement: HTMLElement) => string;
-    getThumbData: (thumbElement: HTMLElement) => {
-        title: string;
-        duration: number;
-    };
-    getThumbImgData: (thumbElement: HTMLElement) => {
-        img: HTMLElement;
-        imgSrc: string;
-    };
-    container: HTMLElement;
-    isPrivate: (element: HTMLElement) => boolean;
-    isHD: (element: HTMLElement) => boolean;
+    doScroll(url: string, offset: number): Promise<void>;
+    private createPaginationGenerator;
+    static create(store: JabronioStore, rules: RulesGlobal, parseData: (document: HTMLElement) => void): InfiniteScroller;
 }
 
-declare interface IRules_2 {
-    paginationStrategy: PaginationStrategy;
-    delay?: number;
-}
+declare type InfiniteScrollerOptions = Pick<InfiniteScroller, 'rules'> & Partial<InfiniteScroller>;
 
 export declare function isMob(): boolean;
 
-declare interface JabroniStore {
-    state: Record<string, boolean | string | number>;
-    localState: Record<string, boolean | string | number>;
-    subscribe: (callback: () => void) => void;
-}
-
 export declare class LazyImgLoader {
     lazyImgObserver: Observer;
     private attributeName;
     constructor(shouldDelazify: (target: Element) => boolean);
-    lazify(_target: Element, img: HTMLImageElement, imgSrc: string): void;
+    lazify(_target: Element, img?: HTMLImageElement, imgSrc?: string): void;
     delazify: (target: HTMLImageElement) => void;
 }
 
-export declare function listenEvents(dom: HTMLElement | Element, events: Array<string>, callback: (e: Event) => void): void;
+export declare function listenEvents(dom: HTMLElement, events: Array<string>, callback: (e: Event) => void): void;
 
 export declare const MOBILE_UA: string;
 
-export declare function objectToFormData(object: Record<string, number | boolean | string>): FormData;
+export declare function objectToFormData<T extends {}>(obj: T): FormData;
 
 export declare class Observer {
     private callback;
     observer: IntersectionObserver;
+    private timeout;
     constructor(callback: (entry: Element) => void);
     observe(target: Element): void;
     throttle(target: Element, throttleTime: number): void;
     handleIntersection(entries: Iterable<IntersectionObserverEntry>): void;
+    dispose(): void;
     static observeWhile(target: Element, callback: () => Promise<boolean> | boolean, throttleTime: number): Observer;
 }
 
@@ -194,11 +142,13 @@ export declare class PaginationStrategy {
     url: URL;
     paginationSelector: string;
     searchParamSelector: string;
+    static _pathnameSelector: RegExp;
     pathnameSelector: RegExp;
+    dataparamSelector: string;
     fixPaginationLast?: (n: number, offset?: number) => number;
     offsetMin: number;
-    constructor(options?: IPaginationStrategy);
-    getPaginationElement(): Element | null;
+    constructor(options?: Partial<PaginationStrategy>);
+    getPaginationElement(): HTMLElement | null;
     get hasPagination(): boolean;
     getPaginationOffset(): number;
     getPaginationLast(): number;
@@ -209,10 +159,13 @@ export declare class PaginationStrategyDataParams extends PaginationStrategy {
     getPaginationLast(): number;
     getPaginationOffset(): number;
     getPaginationUrlGenerator(): (n: number) => string;
+    static testLinks(doc?: HTMLElement | Document): boolean;
 }
 
 export declare class PaginationStrategyPathnameParams extends PaginationStrategy {
     extractPage: (a: HTMLAnchorElement | Location | string) => number;
+    static checkLink(link: URL, pathnameSelector?: RegExp): boolean;
+    static testLinks(links: URL[], options: Partial<PaginationStrategy>): boolean;
     getPaginationLast(): number;
     getPaginationOffset(): number;
     getPaginationUrlGenerator(url_?: URL): (offset: number) => string;
@@ -220,10 +173,11 @@ export declare class PaginationStrategyPathnameParams extends PaginationStrategy
 
 export declare class PaginationStrategySearchParams extends PaginationStrategy {
     extractPage: (a: HTMLAnchorElement | Location | URL | string) => number;
-    static checkLink(link: URL, searchParamSelector?: string): boolean;
     getPaginationLast(): number;
     getPaginationOffset(): number;
     getPaginationUrlGenerator(): (offset: number) => string;
+    static checkLink(link: URL, searchParamSelector?: string): boolean;
+    static testLinks(links: URL[], searchParamSelector?: string): boolean;
 }
 
 export declare function parseCSSUrl(s: string): string;
@@ -234,13 +188,64 @@ export declare function parseDom(html: string): HTMLElement;
 
 export declare function parseIntegerOr(n: string | number, or: number): number;
 
+export declare function querySelectorText(el: HTMLElement, selector?: string): string;
+
 export declare function range(size: number, startAt?: number, step?: number): number[];
 
-export declare function replaceElementTag(e: HTMLElement | Element, tagName: string): HTMLElement;
+export declare function replaceElementTag(e: HTMLElement, tagName: string): HTMLElement;
+
+export declare class RulesGlobal {
+    delay?: number;
+    alternativeGenerator?: () => OffsetGenerator;
+    getThumbUrl(thumb: HTMLElement | HTMLAnchorElement): string;
+    titleSelector: undefined | string;
+    uploaderSelector: undefined | string;
+    durationSelector: undefined | string;
+    getThumbDataStrategy: 'default' | 'auto-select' | 'auto-text';
+    getThumbDataCallback?: (thumb: HTMLElement, thumbData: ThumbData) => void;
+    getThumbData(thumb: HTMLElement): ThumbData;
+    getThumbImgDataAttrSelector: string | undefined;
+    getThumbImgDataStrategy: 'default' | 'auto';
+    getThumbImgData(thumb: HTMLElement): {
+        img?: HTMLImageElement;
+        imgSrc?: string;
+    };
+    containerSelector: string | (() => HTMLElement);
+    intersectionObservable?: HTMLElement;
+    get container(): HTMLElement;
+    thumbsSelector: string;
+    getThumbsStrategy: 'default' | 'auto';
+    getThumbs(html: HTMLElement): HTMLElement[];
+    paginationStrategy: PaginationStrategy;
+    get observable(): HTMLElement;
+    mutationObservers: MutationObserver[];
+    reset(): void;
+    resetOnPaginationOrContainerDeath: boolean;
+    resetOn(): void;
+    customSelectors: Record<string, CustomSelector<any>>;
+    animatePreview?: (doc?: HTMLElement) => void;
+    storeOptions?: JabroniTypes.StoreStateOptions;
+    customScheme?: JabroniTypes.SchemeInput;
+    defaultSchemeOptions: Parameters<typeof setupScheme>[0];
+    store: JabronioStore;
+    scheme: JabroniTypes.SchemeInput;
+    gui: JabronioGUI;
+    dataManager: DataManager;
+    infiniteScroller: InfiniteScroller;
+    private resetInfiniteScroller;
+    initialGrope: 'all-in-one' | 'all-in-all' | undefined;
+    gropeInit(): void;
+    constructor();
+}
 
 export declare function sanitizeStr(s: string): string;
 
-export declare function stringToWords(s: string): Array<string>;
+export declare function splitWith(s: string, c?: string): Array<string>;
+
+declare type ThumbData = {
+    title: string;
+    duration?: number;
+};
 
 export declare class Tick {
     private delay;
@@ -256,10 +261,12 @@ export declare function timeToSeconds(t: string): number;
 
 export declare function wait(milliseconds: number): Promise<unknown>;
 
-export declare function waitForElementExists(parent: HTMLElement | Element, selector: string, callback: (el: Element) => void): void;
+export declare function waitForElementToAppear(parent: HTMLElement, selector: string, callback: (el: Element) => void): MutationObserver;
+
+export declare function waitForElementToDisappear(observable: HTMLElement, callback: () => void): MutationObserver;
 
-export declare function watchDomChangesWithThrottle(element: HTMLElement | Element, callback: () => void, throttle?: number, times?: number, options?: Record<string, boolean>): MutationObserver;
+export declare function watchDomChangesWithThrottle(element: HTMLElement, callback: () => void, throttle?: number, times?: number, options?: MutationObserverInit): MutationObserver;
 
-export declare function watchElementChildrenCount(element: HTMLElement | Element, callback: (observer: MutationObserver, count: number) => void): void;
+export declare function watchElementChildrenCount(element: HTMLElement, callback: (observer: MutationObserver, count: number) => void): MutationObserver;
 
 export { }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "billy-herrington-utils",
   "description": "daddy told us not to be ashamed of our utils",
-  "version": "1.5.9",
+  "version": "2.0.0",
   "license": "MIT",
   "keywords": [
     "utils",
@@ -26,9 +26,9 @@
   "unpkg": "dist/billy-herrington-utils.es.js",
   "exports": {
     ".": {
+      "types": "./dist/index.d.ts",
       "import": "./dist/billy-herrington-utils.es.js",
-      "require": "./dist/billy-herrington-utils.umd.js",
-      "types": "./dist/index.d.ts"
+      "require": "./dist/billy-herrington-utils.umd.js"
     }
   },
   "files": [
@@ -41,8 +41,10 @@
     "preview": "vite preview"
   },
   "devDependencies": {
+    "@types/tampermonkey": "^5.0.5",
+    "jabroni-outfit": "^2.0.92",
     "typescript": "^5.5.3",
-    "vite": "^5.4.0",
+    "vite": "^6.4.1",
     "vite-plugin-dts": "^4.0.3"
   }
-}
+}

package/src/index.ts

@@ -1,6 +1,5 @@
 export { DataManager } from './userscripts/data-manager';
 export { InfiniteScroller } from './userscripts/infinite-scroll';
-export { createInfiniteScroller } from './userscripts/jabroni-outfit-wrap';
 export { getPaginationStrategy } from './userscripts/pagination-parsing';
 export {
   PaginationStrategy,
@@ -8,6 +7,7 @@ export {
   PaginationStrategyPathnameParams,
   PaginationStrategySearchParams,
 } from './userscripts/pagination-parsing/pagination-strategies';
+export { RulesGlobal } from './userscripts/rules';
 export { chunks, range } from './utils/arrays';
 export { AsyncPool, computeAsyncOneAtTime, wait } from './utils/async';
 export { isMob } from './utils/device';
@@ -18,14 +18,27 @@ export {
   findNextSibling,
   getAllUniqueParents,
   parseDom,
+  querySelectorText,
   replaceElementTag,
-  waitForElementExists,
+  waitForElementToAppear,
+  waitForElementToDisappear,
   watchDomChangesWithThrottle,
   watchElementChildrenCount,
 } from './utils/dom';
 export { listenEvents, Tick } from './utils/events';
-export { fetchHtml, fetchText, fetchWith, MOBILE_UA, objectToFormData } from './utils/fetch';
+export {
+  fetchHtml,
+  fetchText,
+  fetchWith,
+  MOBILE_UA,
+  objectToFormData,
+} from './utils/fetch';
 export { circularShift } from './utils/math';
 export { LazyImgLoader, Observer } from './utils/observers';
-export { parseCSSUrl, parseDataParams, parseIntegerOr, timeToSeconds } from './utils/parsers';
-export { sanitizeStr, stringToWords } from './utils/strings';
+export {
+  parseCSSUrl,
+  parseDataParams,
+  parseIntegerOr,
+  timeToSeconds,
+} from './utils/parsers';
+export { sanitizeStr, splitWith } from './utils/strings';

package/src/types/globals.d.ts

@@ -1,2 +0,0 @@
-declare var GM_addStyle: (css: string) => void;
-declare var unsafeWindow: Window & typeof globalThis;

package/src/userscripts/data-manager/data-filter.ts

@@ -0,0 +1,110 @@
+import type { StoreState } from 'jabroni-outfit';
+import { RegexFilter } from '../../utils/strings/regexes';
+import type { RulesGlobal } from '../rules';
+import type { DataElement } from '.';
+
+export type CustomSelector<R> = {
+  handle: (el: DataElement, state: StoreState, $preDefineResult?: R) => boolean;
+  $preDefine?: (state: StoreState) => R;
+};
+
+interface FilterResult {
+  tag: string;
+  condition: boolean;
+}
+
+export type FilterFunction = (v: DataElement) => FilterResult;
+
+export class DataFilter {
+  public filters = new Map<string, () => FilterFunction>();
+
+  constructor(
+    private rules: RulesGlobal,
+    private state: StoreState,
+  ) {
+    this.registerFilters(DataFilter.customFiltersDefault);
+    this.registerFilters(rules.customSelectors);
+    this.applyCSSFilters();
+  }
+
+  public applyCSSFilters() {
+    Object.keys(this.filters).forEach((name) => {
+      const className = `.filter-${name.toLowerCase().slice(6)}`;
+      GM_addStyle(`${className} { display: none !important; content-visibility: auto; }`);
+    });
+  }
+
+  public registerFilters(customFilters: Record<string, CustomSelector<any>>) {
+    Object.entries(customFilters).forEach(([k, v]) => {
+      if (!Object.hasOwn(this.rules.customSelectors, k)) {
+        this.rules.customSelectors[k] = v;
+      }
+      this.registerFilter(k);
+    });
+  }
+
+  public registerFilter(CustomSelectorName: string) {
+    const handler = this.rules.customSelectors[CustomSelectorName];
+
+    const fn = (): FilterFunction => {
+      const preDefined = handler.$preDefine?.(this.state);
+
+      return (v: DataElement) => {
+        const result = handler.handle(v, this.state, preDefined);
+
+        return {
+          condition: result,
+          tag: `filter-${CustomSelectorName}`,
+        };
+      };
+    };
+
+    this.filters.set(CustomSelectorName, fn);
+  }
+
+  static customFiltersDefault: Record<string, CustomSelector<any>> = {
+    isPrivate: {
+      handle(el, state) {
+        const isPrivate = !!(el.element as HTMLElement).querySelector('.private');
+        return (state.filterPrivate as boolean) && isPrivate;
+      },
+    },
+    isPublic: {
+      handle(el, state) {
+        const isPublic = !!(el.element as HTMLElement).querySelector('.public');
+        return (state.filterPublic as boolean) && isPublic;
+      },
+    },
+    filterDuration: {
+      handle(el, state, preDefined) {
+        const d = el.duration as number;
+        const notInRange = d < (preDefined.from as number) || d > (preDefined.to as number);
+        return (state.filterDuration as boolean) && notInRange;
+      },
+      $preDefine: (state) => {
+        const f = (x: number) => (state.filterDurationMinutes ? x * 60 : x);
+        const from = f(state.filterDurationFrom as number);
+        const to = f(state.filterDurationTo as number);
+        return { from, to };
+      },
+    },
+    filterExclude: {
+      handle(el, state, searchFilter) {
+        return (
+          (state.filterExclude as boolean) &&
+          (searchFilter as RegexFilter).hasNone(el.title as string)
+        );
+      },
+      $preDefine: (state) => new RegexFilter(state.filterExcludeWords as string),
+    },
+    filterInclude: {
+      handle(el, state, searchFilter) {
+        return (
+          (state.filterInclude as boolean) &&
+          (searchFilter as RegexFilter).hasEvery(el.title as string)
+        );
+      },
+      $preDefine: (state) => new RegexFilter(state.filterIncludeWords as string),
+    },
+  };
+}