pervert-monkey 1.0.0

package/src/utils/observers/index.ts

@@ -0,0 +1,44 @@
+export { LazyImgLoader } from './lazy-image-loader';
+
+export class Observer {
+  public observer: IntersectionObserver;
+  private timeout?: number;
+  constructor(private callback: (entry: Element) => void) {
+    this.observer = new IntersectionObserver(this.handleIntersection.bind(this));
+  }
+
+  observe(target: Element) {
+    this.observer.observe(target);
+  }
+
+  throttle(target: Element, throttleTime: number) {
+    this.observer.unobserve(target);
+    this.timeout = window.setTimeout(() => this.observer.observe(target), throttleTime);
+  }
+
+  handleIntersection(entries: Iterable<IntersectionObserverEntry>) {
+    for (const entry of entries) {
+      if (entry.isIntersecting) {
+        this.callback(entry.target);
+      }
+    }
+  }
+
+  dispose() {
+    if (this.timeout) clearTimeout(this.timeout);
+    this.observer.disconnect();
+  }
+
+  static observeWhile(
+    target: Element,
+    callback: () => Promise<boolean> | boolean,
+    throttleTime: number,
+  ) {
+    const observer_ = new Observer(async (target: Element) => {
+      const condition = await callback();
+      if (condition) observer_.throttle(target, throttleTime);
+    });
+    observer_.observe(target);
+    return observer_;
+  }
+}

package/src/utils/observers/lazy-image-loader.ts

@@ -0,0 +1,27 @@
+import { Observer } from ".";
+
+export class LazyImgLoader {
+  public lazyImgObserver: Observer;
+  private attributeName = 'data-lazy-load';
+
+  constructor(shouldDelazify: (target: Element) => boolean) {
+    this.lazyImgObserver = new Observer((target: Element) => {
+      if (shouldDelazify(target)) {
+        this.delazify(target as HTMLImageElement);
+      }
+    });
+  }
+
+  lazify(_target: Element, img?: HTMLImageElement, imgSrc?: string) {
+    if (!img || !imgSrc) return;
+    img.setAttribute(this.attributeName, imgSrc);
+    img.src = '';
+    this.lazyImgObserver.observe(img);
+  }
+
+  delazify = (target: HTMLImageElement) => {
+    this.lazyImgObserver.observer.unobserve(target);
+    target.src = target.getAttribute(this.attributeName) as string;
+    target.removeAttribute(this.attributeName);
+  };
+}

package/src/utils/parsers/index.ts

@@ -0,0 +1,30 @@
+export { formatTimeToHHMMSS, timeToSeconds } from './time-parser';
+
+export function parseIntegerOr(n: string | number, or: number): number {
+  const num = Number(n);
+  return Number.isSafeInteger(num) ? num : or;
+}
+
+// "data:02;body+head:async;void:;zero:;"
+export function parseDataParams(str: string): Record<string, string> {
+  const paramsStr = decodeURI(str.trim()).split(';');
+  return paramsStr.reduce(
+    (acc, s) => {
+      const parsed = s.match(/([+\w]+):([\w\- ]+)?/);
+      if (parsed) {
+        const [, key, value] = parsed;
+        if (value) {
+          key.split('+').forEach((p) => {
+            acc[p] = value;
+          });
+        }
+      }
+      return acc;
+    },
+    {} as Record<string, string>,
+  );
+}
+
+export function parseCssUrl(s: string) {
+  return s.replace(/url\("|"\).*/g, '');
+}

package/src/utils/parsers/time-parser.ts

@@ -0,0 +1,28 @@
+/**
+ * Converts a duration string (e.g., "1h 22min 3sec") to HH:MM:SS format.
+ * @param timeStr - The duration string to format.
+ * @returns A string in the format HH:MM:SS.
+ */
+export function formatTimeToHHMMSS(timeStr: string): string {
+  const pad = (num: number): string => num.toString().padStart(2, '0');
+
+  const h = timeStr.match(/(\d+)\s*h/)?.[1] || '0';
+  const m = timeStr.match(/(\d+)\s*mi?n/)?.[1] || '0';
+  const s = timeStr.match(/(\d+)\s*sec/)?.[1] || '0';
+
+  return `${pad(+h)}:${pad(+m)}:${pad(+s)}`;
+}
+
+/**
+ * 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 function timeToSeconds(timeStr: string): number {
+  const normalized = /[a-zA-Z]/.test(timeStr) ? formatTimeToHHMMSS(timeStr) : timeStr;
+
+  return normalized
+    .split(':')
+    .reverse()
+    .reduce((total, unit, index) => total + parseInt(unit, 10) * 60 ** index, 0);
+}

package/src/utils/strings/index.ts

@@ -0,0 +1,10 @@
+export function splitWith(s: string, c: string = ','): Array<string> {
+  return s
+    .split(c)
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+export function sanitizeStr(s: string) {
+  return s?.replace(/\n|\t/g, ' ').replace(/ {2,}/g, ' ').trim() || '';
+}

package/src/utils/strings/regexes.ts

@@ -0,0 +1,35 @@
+import { memoize } from '../objects';
+import { splitWith } from '.';
+
+export class RegexFilter {
+  private regexes: RegExp[];
+
+  constructor(str: string, flags: string = 'gi') {
+    this.regexes = memoize(this.compileSearchRegex)(str, flags);
+  }
+
+  // 'dog,bog,f:girl' or r:dog|bog... => [r/dog/i, r/bog/i, r/(^|\ )girl($|\ )/i]
+  private compileSearchRegex(str: string, flags: string): RegExp[] {
+    try {
+      if (str.startsWith('r:')) return [new RegExp(str.slice(2), flags)];
+
+      const regexes = splitWith(str)
+        .map(
+          (s) => s.replace(/f:(\w+)/g, (_, w) => `(^|\\ |,)${w}($|\\ |,)`), // full word
+        )
+        .map((_) => new RegExp(_, flags));
+
+      return regexes;
+    } catch (_) {
+      return [];
+    }
+  }
+
+  public hasEvery(str: string) {
+    return this.regexes.every((r) => r.test(str));
+  }
+
+  public hasNone(str: string) {
+    return this.regexes.every((r) => !r.test(str));
+  }
+}

package/src/vite-env.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="vite/client" />
+/// <reference types="vite-plugin-monkey/client" />
+/// <reference types="vite-plugin-monkey/global" />
+/// <reference types="vite-plugin-monkey/style" />