billy-herrington-utils 2.0.6 → 2.1.0

package/dist/index.d.ts

@@ -1,59 +1,15 @@
-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;
-    private cur;
-    private finished;
-    private _resolve?;
-    static doNAsyncAtOnce(max?: number, pool?: Array<AsyncPoolTask | (() => Promise<void>)>): Promise<boolean>;
-    constructor(max?: number, pool?: Array<AsyncPoolTask>);
-    private getHighPriorityFirst;
-    private runTask;
-    private runTasks;
-    run(): Promise<boolean>;
-    push(x: AsyncPoolTask | (() => Promise<void>)): void;
-}
+declare type AnyFunction = (...args: any[]) => any;
 
-declare interface AsyncPoolTask {
-    v: () => Promise<void>;
-    p: number;
-}
+export declare function checkHomogenity<T extends HTMLElement>(a: T, b: T, options: {
+    id?: boolean;
+    className?: boolean;
+}): boolean;
 
-export declare function chunks<T>(arr: Array<T>, n: number): Array<Array<T>>;
+export declare function chunks<T>(arr: T[], size: number): T[][];
 
 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, 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;
-    private dataFilter;
-    constructor(rules: RulesGlobal, state: StoreState);
-    isFiltered(el: HTMLElement): boolean;
-    applyFilters: (filters?: {
-        [key: string]: boolean;
-    }, offset?: number) => void;
-    filterAll: (offset?: number) => void;
-    parseData: (html: HTMLElement, container?: HTMLElement, removeDuplicates?: boolean, shouldLazify?: boolean) => void;
-    sortBy<K extends keyof DataElement>(key: K): void;
-}
+export declare function copyAttributes<T extends Element = HTMLElement>(target: T, source: T): void;
 
 export declare function downloader(options?: {
     append: string;
@@ -64,50 +20,23 @@ export declare function downloader(options?: {
 
 export declare function exterminateVideo(video: HTMLVideoElement): void;
 
-export declare const fetchHtml: (url: string) => Promise<HTMLElement>;
-
-export declare const fetchText: (url: string) => Promise<string>;
+export declare const fetchHtml: (input: RequestInfo | URL) => Promise<HTMLElement>;
 
-export declare function fetchWith(url: string, options?: {
-    html?: boolean;
-    mobile?: boolean;
-}): Promise<string | HTMLElement>;
-
-export declare function findNextSibling(el: HTMLElement): Element | null;
-
-declare type GeneratorResult = {
-    url: string;
-    offset: number;
-};
+export declare const fetchJson: (input: RequestInfo | URL) => Promise<JSON>;
 
-export declare function getAllUniqueParents(elements: HTMLCollection | HTMLElement[]): HTMLElement[];
+export declare const fetchText: (input: RequestInfo | URL) => Promise<string>;
 
-export declare function getPaginationStrategy(options: Partial<PaginationStrategy>): PaginationStrategy;
+export declare function fetchWith<T extends JSON | string | HTMLElement>(input: RequestInfo | URL, options: {
+    init?: RequestInit;
+    type: 'json' | 'html' | 'text';
+    mobile?: boolean;
+}): Promise<T>;
 
-export declare class InfiniteScroller {
-    enabled: boolean;
-    delay: number;
-    paginationOffset: number;
-    writeHistory: boolean;
-    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>;
-    doScroll(url: string, offset: number): Promise<void>;
-    private createPaginationGenerator;
-    static create(store: JabronioStore, rules: RulesGlobal, parseData: (document: HTMLElement) => void): InfiniteScroller;
-}
+export declare function findNextSibling<T extends Element = HTMLElement>(e: T): Element | null;
 
-declare type InfiniteScrollerOptions = Pick<InfiniteScroller, 'rules'> & Partial<InfiniteScroller>;
+export declare function getCommonParents(elements: HTMLCollection | HTMLElement[]): HTMLElement[];
 
-export declare function isMob(): boolean;
+export declare function instantiateTemplate(sourceSelector: string, attributeUpdates: Record<string, string>, contentUpdates: Record<string, string>): string;
 
 export declare class LazyImgLoader {
     lazyImgObserver: Observer;
@@ -117,16 +46,19 @@ export declare class LazyImgLoader {
     delazify: (target: HTMLImageElement) => void;
 }
 
-export declare function listenEvents(dom: HTMLElement, events: Array<string>, callback: (e: Event) => void): void;
+export declare function memoize<T extends AnyFunction>(fn: T): MemoizedFunction<T>;
 
-export declare const MOBILE_UA: string;
+declare interface MemoizedFunction<T extends AnyFunction> extends CallableFunction {
+    (...args: Parameters<T>): ReturnType<T>;
+    clear: () => void;
+}
 
 export declare function objectToFormData<T extends {}>(obj: T): FormData;
 
 export declare class Observer {
     private callback;
     observer: IntersectionObserver;
-    private timeout;
+    private timeout?;
     constructor(callback: (entry: Element) => void);
     observe(target: Element): void;
     throttle(target: Element, throttleTime: number): void;
@@ -135,118 +67,60 @@ export declare class Observer {
     static observeWhile(target: Element, callback: () => Promise<boolean> | boolean, throttleTime: number): Observer;
 }
 
-declare type OffsetGenerator = Generator<GeneratorResult> | AsyncGenerator<GeneratorResult>;
-
-export declare class PaginationStrategy {
-    doc: Document;
-    url: URL;
-    paginationSelector: string;
-    searchParamSelector: string;
-    static _pathnameSelector: RegExp;
-    pathnameSelector: RegExp;
-    dataparamSelector: string;
-    fixPaginationLast?: (n: number, offset?: number) => number;
-    offsetMin: number;
-    constructor(options?: Partial<PaginationStrategy>);
-    getPaginationElement(): HTMLElement | null;
-    get hasPagination(): boolean;
-    getPaginationOffset(): number;
-    getPaginationLast(): number;
-    getPaginationUrlGenerator(): (_: number) => string;
+export declare class OnHover {
+    private container;
+    private subjectSelector;
+    private onOver;
+    private onLeave?;
+    private handleLeaveEvent;
+    private handleEvent;
+    private target;
+    private leaveSubject;
+    private onOverFinally;
+    constructor(container: HTMLElement, subjectSelector: (target: HTMLElement) => boolean, onOver: (target: HTMLElement) => void | {
+        onOverCallback?: () => void;
+        leaveTarget?: HTMLElement;
+    }, onLeave?: ((target: HTMLElement) => void) | undefined);
+    static create(...args: ConstructorParameters<typeof OnHover>): OnHover;
 }
 
-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;
-}
-
-export declare class PaginationStrategySearchParams extends PaginationStrategy {
-    extractPage: (a: HTMLAnchorElement | Location | URL | string) => number;
-    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;
+export declare function parseCssUrl(s: string): string;
 
 export declare function parseDataParams(str: string): Record<string, string>;
 
-export declare function parseDom(html: string): HTMLElement;
+export declare function parseHtml(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 propsDifference<T extends Record<string, unknown>, U extends object>(obj1: T | U, obj2: T | U): {
+    d1: string[];
+    d2: string[];
+};
 
-export declare function range(size: number, startAt?: number, step?: number): number[];
+export declare function querySelectorLast<T extends Element = HTMLElement>(root: ParentNode | undefined, selector: string): T | undefined;
 
-export declare function replaceElementTag(e: HTMLElement, tagName: string): HTMLElement;
+export declare function querySelectorLastNumber(selector: string, e?: ParentNode): number;
 
-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[];
-    paginationStrategyOptions: Partial<PaginationStrategy>;
-    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;
-    gui: JabronioGUI;
-    dataManager: DataManager;
-    infiniteScroller?: InfiniteScroller;
-    private resetInfiniteScroller;
-    initialGrope: 'all-in-one' | 'all-in-all' | undefined;
-    gropeInit(): void;
-    constructor(options: Partial<RulesGlobal>);
+export declare function querySelectorText(e: ParentNode, selector?: string): string;
+
+export declare function range(size: number, start?: number, step?: number): number[];
+
+export declare class RegexFilter {
+    private regexes;
+    constructor(str: string, flags?: string);
+    private compileSearchRegex;
+    hasEvery(str: string): boolean;
+    hasNone(str: string): boolean;
 }
 
+export declare function removeClassesAndDataAttributes(element: HTMLElement, keyword: string): void;
+
+export declare function replaceElementTag(e: HTMLElement, tagName: string): HTMLElement;
+
 export declare function sanitizeStr(s: string): string;
 
 export declare function splitWith(s: string, c?: string): Array<string>;
 
-declare type ThumbData = {
-    title: string;
-    duration?: number;
-};
-
 export declare class Tick {
     private delay;
     private startImmediate;
@@ -257,16 +131,21 @@ export declare class Tick {
     stop(): void;
 }
 
-export declare function timeToSeconds(t: string): number;
+/**
+ * Converts a time string (HH:MM:SS or duration format) to total seconds.
+ * @param timeStr - The time string to convert.
+ * @returns The total number of seconds.
+ */
+export declare function timeToSeconds(timeStr: string): number;
 
 export declare function wait(milliseconds: number): Promise<unknown>;
 
-export declare function waitForElementToAppear(parent: HTMLElement, selector: string, callback: (el: Element) => void): MutationObserver;
+export declare function waitForElementToAppear(parent: ParentNode, selector: string, callback: (el: Element) => void): MutationObserver;
 
 export declare function waitForElementToDisappear(observable: HTMLElement, callback: () => void): MutationObserver;
 
 export declare function watchDomChangesWithThrottle(element: HTMLElement, callback: () => void, throttle?: number, times?: number, options?: MutationObserverInit): MutationObserver;
 
-export declare function watchElementChildrenCount(element: HTMLElement, callback: (observer: MutationObserver, count: number) => void): MutationObserver;
+export declare function watchElementChildrenCount(element: ParentNode, 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": "2.0.6",
+  "version": "2.1.0",
   "license": "MIT",
   "keywords": [
     "utils",
@@ -9,7 +9,19 @@
     "dom",
     "fetch",
     "arrays",
-    "typescript"
+    "typescript",
+    "async",
+    "promises",
+    "mutation-observer",
+    "throttle",
+    "memoize",
+    "lazy-loading",
+    "string-manipulation",
+    "formatting",
+    "html-parser",
+    "helpers",
+    "toolkit",
+    "dom-manipulation"
   ],
   "author": "smartacephale atm.mormon@protonmail.com (https://github.com/smartacephale)",
   "homepage": "https://github.com/smartacephale/billy-herrington-utils#readme",
@@ -41,10 +53,9 @@
     "preview": "vite preview"
   },
   "devDependencies": {
-    "@types/tampermonkey": "^5.0.5",
-    "jabroni-outfit": "^2.0.92",
-    "typescript": "^5.5.3",
-    "vite": "^6.4.1",
-    "vite-plugin-dts": "^4.0.3"
+    "@types/node": "^25.2.3",
+    "typescript": "^5.9.3",
+    "vite": "^7.3.1",
+    "vite-plugin-dts": "^4.5.4"
   }
 }

package/src/index.ts

@@ -1,44 +1 @@
-export { DataManager } from './userscripts/data-manager';
-export { InfiniteScroller } from './userscripts/infinite-scroll';
-export { getPaginationStrategy } from './userscripts/pagination-parsing';
-export {
-  PaginationStrategy,
-  PaginationStrategyDataParams,
-  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';
-export {
-  copyAttributes,
-  downloader,
-  exterminateVideo,
-  findNextSibling,
-  getAllUniqueParents,
-  parseDom,
-  querySelectorText,
-  replaceElementTag,
-  waitForElementToAppear,
-  waitForElementToDisappear,
-  watchDomChangesWithThrottle,
-  watchElementChildrenCount,
-} from './utils/dom';
-export { listenEvents, Tick } from './utils/events';
-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, splitWith } from './utils/strings';
+export * from './utils'

package/src/types/index.ts

@@ -0,0 +1,7 @@
+export type AnyFunction = (...args: any[]) => any;
+
+export type NonFunctionKeys<T> = {
+  [K in keyof T]: T[K] extends AnyFunction ? never : K;
+}[keyof T];
+
+export type NonFunctionProperties<T> = Pick<T, NonFunctionKeys<T>>;

package/src/utils/arrays/index.ts

@@ -1,9 +1,15 @@
-export function chunks<T>(arr: Array<T>, n: number): Array<Array<T>> {
-  return Array.from({ length: Math.ceil(arr.length / n) }, (_, i) =>
-    arr.slice(i * n, i * n + n),
+export function chunks<T>(arr: T[], size: number): T[][] {
+  return Array.from({ length: Math.ceil(arr.length / size) }, (_, i) =>
+    arr.slice(i * size, i * size + size),
   );
 }
 
-export function range(size: number, startAt: number = 1, step: number = 1): number[] {
-  return Array.from({ length: size }, (_, index) => startAt + index * step);
+export function* irange(start: number = 1, step: number = 1) {
+  for (let i = start; ; i += step) {
+    yield i;
+  }
+}
+
+export function range(size: number, start: number = 1, step: number = 1): number[] {
+  return irange(start, step).take(size).toArray();
 }

package/src/utils/async/index.ts

@@ -1,91 +1,3 @@
-// https://2ality.com/2016/10/asynchronous-iteration.html
-export async function computeAsyncOneAtTime(iterable: Iterable<() => Promise<void>>) {
-  const res = [];
-  for await (const f of iterable) {
-    try {
-      const r = await f();
-      res.push(r);
-    } catch (e) {
-      console.error(e);
-    }
-  }
-  return res;
-}
-
 export function wait(milliseconds: number) {
   return new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
-
-interface AsyncPoolTask {
-  v: () => Promise<void>;
-  p: number;
-}
-
-export class AsyncPool {
-  private cur = 0;
-  private finished: Promise<boolean>;
-  private _resolve?: (value: boolean | PromiseLike<boolean>) => void;
-
-  public static async doNAsyncAtOnce(
-    max = 1,
-    pool: Array<AsyncPoolTask | (() => Promise<void>)> = [],
-  ) {
-    const spool = new AsyncPool(max);
-    pool.forEach((f) => {
-      spool.push(f);
-    });
-    return spool.run();
-  }
-
-  constructor(
-    private max = 1,
-    private pool: Array<AsyncPoolTask> = [],
-  ) {
-    this.finished = new Promise((resolve) => {
-      this._resolve = resolve;
-    });
-  }
-
-  private getHighPriorityFirst(p = 0): (() => Promise<void>) | undefined {
-    if (p > 3 || this.pool.length === 0) return undefined;
-    const i = this.pool.findIndex((e) => e.p === p);
-    if (i >= 0) {
-      const res = this.pool[i].v;
-      this.pool.splice(i, 1);
-      return res;
-    }
-    return this.getHighPriorityFirst(p + 1);
-  }
-
-  private async runTask() {
-    this.cur++;
-    const f = this.getHighPriorityFirst();
-    try {
-      await f?.();
-    } catch (e) {
-      console.error(e);
-    }
-    this.cur--;
-    this.runTasks();
-  }
-
-  private runTasks() {
-    if (!this.pool.length) {
-      this._resolve?.(true);
-      return;
-    }
-    if (this.cur < this.max) {
-      this.runTask();
-      this.runTasks();
-    }
-  }
-
-  public async run() {
-    this.runTasks();
-    return this.finished;
-  }
-
-  public push(x: AsyncPoolTask | (() => Promise<void>)) {
-    this.pool.push('p' in x ? x : { v: x, p: 0 });
-  }
-}

package/src/utils/dom/{observers.ts → dom-observers.ts}

@@ -1,5 +1,5 @@
 export function waitForElementToAppear(
-  parent: HTMLElement,
+  parent: ParentNode,
   selector: string,
   callback: (el: Element) => void,
 ) {
@@ -28,7 +28,7 @@ export function waitForElementToDisappear(observable: HTMLElement, callback: ()
 }
 
 export function watchElementChildrenCount(
-  element: HTMLElement,
+  element: ParentNode,
   callback: (observer: MutationObserver, count: number) => void,
 ) {
   let count = element.children.length;
@@ -67,7 +67,7 @@ export function watchDomChangesWithThrottle(
     if (lastMutationTime && now - lastMutationTime < throttle) {
       timeout && clearTimeout(timeout);
     }
-    timeout = setTimeout(callback, throttle);
+    timeout = window.setTimeout(callback, throttle);
     lastMutationTime = now;
   });