multporn-api-sdk 0.1.1 → 0.1.3

package/dist/types/index.d.ts

@@ -0,0 +1,228 @@
+type ListingItem = {
+    title: string;
+    url: string;
+    thumb?: string;
+    proxiedThumb?: string;
+};
+type ExposedOption = {
+    value: string;
+    label: string;
+    selected?: boolean;
+};
+type ExposedSelect = {
+    name: string;
+    label?: string;
+    options: ExposedOption[];
+};
+interface SortingUI {
+    actionPath: string;
+    selects: ExposedSelect[];
+    appliedParams: Record<string, string>;
+}
+type Page<T> = {
+    page: number;
+    items: T[];
+    hasNext: boolean;
+    totalPages?: number;
+    pageSize?: number;
+    alphabet?: AlphabetBlock;
+    sorting?: SortingUI;
+};
+type Post = {
+    title: string;
+    url: string;
+    images: string[];
+    tags: string[];
+    author: string | null;
+};
+type ViewName = 'new_mini' | 'user_upload_front' | 'updated_manga' | 'updated_manga_promoted' | 'updated_games' | 'random_top_comics' | 'top_random_characters';
+type UpdatesResult = {
+    items: ListingItem[];
+    first: number;
+    last: number;
+    html: string;
+    viewName: string;
+};
+type MultpornUpdatesParams = {
+    first?: number;
+    last?: number;
+    view_args?: string;
+    view_path?: string;
+    view_base_path?: string;
+    view_display_id?: string;
+    view_name?: ViewName | string;
+    jcarousel_dom_id?: string | number;
+};
+type ResolvedListingRoute = {
+    route: 'listing';
+    data: Page<ListingItem> & {
+        absoluteUrl: string;
+        path: string;
+    };
+};
+type ResolvedViewerRoute = {
+    route: 'viewer';
+    data: {
+        absoluteUrl: string;
+        viewer: {
+            kind: 'images' | 'video' | 'other';
+            images?: Array<{
+                original?: string;
+                large?: string;
+                medium?: string;
+                small?: string;
+                thumb?: string;
+                proxied?: string;
+            }>;
+            video?: {
+                poster?: string;
+                sources: Array<{
+                    url?: string;
+                    proxied?: string;
+                    type?: string;
+                    label?: string;
+                }>;
+            };
+            meta?: Record<string, unknown>;
+        };
+        recommendations?: ListingItem[];
+    };
+};
+type ResolvedRoute = ResolvedListingRoute | ResolvedViewerRoute;
+type AlphabetSection = 'comics' | 'category_comic' | 'characters' | 'authors_comics' | 'pipictures' | 'porn_gifs' | 'manga' | 'authors_hentai';
+type AlphabetLetter = {
+    label: string;
+    value: string;
+    href: string;
+    count?: number;
+    active?: boolean;
+};
+interface AlphabetBlock {
+    section: string;
+    letters: AlphabetLetter[];
+}
+type LinkItem = {
+    title: string;
+    url: string;
+};
+type ViewerKind = 'manga' | 'comics' | 'pictures' | 'humor' | 'video' | 'game' | 'other' | 'images';
+interface ViewerImage {
+    original: string;
+    large?: string;
+    medium?: string;
+    small?: string;
+    thumb?: string;
+    proxied?: string;
+}
+interface ViewerVideoSource {
+    url: string;
+    type?: string;
+    label?: string;
+    proxied?: string;
+}
+interface ViewerVideo {
+    poster?: string;
+    sources: ViewerVideoSource[];
+}
+interface ViewerMeta {
+    nodeId: number | null;
+    fieldSys: string | null;
+    title: string;
+    kind: ViewerKind;
+    breadcrumbs: LinkItem[];
+    authors: LinkItem[];
+    sections: LinkItem[];
+    tags: LinkItem[];
+    characters: LinkItem[];
+    userTags: LinkItem[];
+    rating?: number;
+    votes?: number;
+    views?: number;
+    related?: LinkItem[];
+}
+interface ViewerResult {
+    kind: ViewerKind;
+    meta: ViewerMeta;
+    images?: ViewerImage[];
+    video?: ViewerVideo;
+}
+type ListingPayload = {
+    page: Page<ListingItem>;
+    absoluteUrl: string;
+    path: string;
+    title?: string;
+    breadcrumbs?: LinkItem[];
+};
+type ViewerPayload = {
+    viewer: ViewerResult;
+    absoluteUrl: string;
+    path: string;
+    recommendations?: ListingItem[];
+};
+interface ResolveOptions {
+    proxyImage?: (url: string) => string;
+    proxyVideo?: (url: string) => string;
+    signal?: AbortSignal;
+}
+type ListingQuery = Record<string, string | number | boolean | undefined>;
+
+type RetryPolicy = {
+    retries: number;
+    factor: number;
+    minDelayMs: number;
+    maxDelayMs: number;
+    retryOn: (status?: number) => boolean;
+};
+type HttpClientOptions = {
+    baseURL: string;
+    headers?: Record<string, string>;
+    timeoutMs?: number;
+    retry?: Partial<RetryPolicy>;
+    userAgent?: string;
+};
+
+type DomDocument = any;
+type DomElement = any;
+interface DomApi {
+    parse(html: string): DomDocument;
+    qsa(ctx: DomDocument | DomElement, selector: string): DomElement[];
+    qs(ctx: DomDocument | DomElement, selector: string): DomElement | null;
+    text(el?: DomElement | null): string;
+    attr(el: DomElement | null | undefined, name: string): string | undefined;
+    closest(el: DomElement | null | undefined, selector: string): DomElement | null;
+}
+
+type MultpornClientOptions = Omit<HttpClientOptions, 'baseURL'> & {
+    baseURL?: string;
+    dom: DomApi;
+};
+declare class MultpornClientCore {
+    private http;
+    private baseURL;
+    private dom;
+    constructor(opts: MultpornClientOptions);
+    private text;
+    private attr;
+    private pickImg;
+    private parseListing;
+    private parseHasNext;
+    private buildListURL;
+    latest(page?: number, params?: ListingQuery): Promise<Page<ListingItem>>;
+    listByPath(path: string | undefined, page?: number, params?: ListingQuery & {
+        letter?: string;
+    }): Promise<Page<ListingItem>>;
+    search(q: string, page?: number): Promise<Page<ListingItem>>;
+    private parsePost;
+    getPost(urlOrSlug: string): Promise<Post>;
+    resolveSmart(urlOrSlug: string, _opts?: ResolveOptions): Promise<ResolvedRoute>;
+    alphabetLetters(section: AlphabetSection): Promise<AlphabetLetter[]>;
+    alphabet(section: AlphabetSection, letter: string, page?: number): Promise<Page<ListingItem>>;
+    updates(params?: Partial<Record<string, string | number>> & {
+        view_name?: string;
+    }): Promise<UpdatesResult>;
+    viewUpdates(viewName: string, params?: Omit<{
+        [k: string]: string | number;
+    }, 'view_name'>): Promise<UpdatesResult>;
+}
+
+export { type AlphabetBlock, type AlphabetLetter, type AlphabetSection, type ExposedOption, type ExposedSelect, type LinkItem, type ListingItem, type ListingPayload, type ListingQuery, MultpornClientCore as MultpornClient, type MultpornUpdatesParams, type Page, type Post, type ResolveOptions, type ResolvedListingRoute, type ResolvedRoute, type ResolvedViewerRoute, type SortingUI, type UpdatesResult, type ViewName, type ViewerImage, type ViewerKind, type ViewerMeta, type ViewerPayload, type ViewerResult, type ViewerVideo, type ViewerVideoSource };

package/dist/types/index.js

@@ -0,0 +1,452 @@
+// src/http.ts
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function hasAbortController() {
+  return typeof AbortController !== "undefined";
+}
+async function fetchWithTimeout(url, init, timeoutMs) {
+  if (hasAbortController()) {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => {
+      try {
+        ctrl.abort();
+      } catch {
+      }
+    }, timeoutMs);
+    try {
+      const res = await fetch(url, { ...init, signal: ctrl.signal });
+      clearTimeout(timer);
+      return res;
+    } catch (e) {
+      clearTimeout(timer);
+      throw e;
+    }
+  }
+  return await Promise.race([
+    fetch(url, init),
+    new Promise(
+      (_, reject) => setTimeout(() => reject(new HttpError("Request timeout")), timeoutMs)
+    )
+  ]);
+}
+var defaultRetryPolicy = {
+  retries: 2,
+  factor: 2,
+  minDelayMs: 300,
+  maxDelayMs: 3e3,
+  retryOn: (status) => {
+    if (status == null) return true;
+    return status >= 500 && status <= 599;
+  }
+};
+var HttpError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "HttpError";
+  }
+};
+var HttpClient = class {
+  baseURL;
+  headers;
+  timeoutMs;
+  retry;
+  userAgent;
+  constructor(opts) {
+    this.baseURL = opts.baseURL.replace(/\/+$/, "");
+    this.headers = opts.headers ?? {};
+    this.timeoutMs = opts.timeoutMs ?? 15e3;
+    this.retry = { ...defaultRetryPolicy, ...opts.retry ?? {} };
+    this.userAgent = opts.userAgent ?? "Mozilla/5.0 (Windows NT 10.0; Win32; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118 Safari/537.36";
+  }
+  buildURL(pathOrUrl) {
+    try {
+      return new URL(pathOrUrl).toString();
+    } catch {
+      return new URL(pathOrUrl.replace(/^\//, ""), this.baseURL + "/").toString();
+    }
+  }
+  async getHtml(pathOrUrl, attempt = 0) {
+    const url = this.buildURL(pathOrUrl);
+    try {
+      const res = await fetchWithTimeout(
+        url,
+        {
+          method: "GET",
+          headers: {
+            "User-Agent": this.userAgent,
+            Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+            ...this.headers
+          }
+        },
+        this.timeoutMs
+      );
+      if (!res.ok) {
+        if (this.retry.retryOn(res.status) && attempt < this.retry.retries) {
+          const delay = Math.min(
+            this.retry.maxDelayMs,
+            this.retry.minDelayMs * this.retry.factor ** attempt
+          );
+          await sleep(delay);
+          return this.getHtml(pathOrUrl, attempt + 1);
+        }
+        throw new HttpError(`HTTP ${res.status}`, res.status);
+      }
+      return await res.text();
+    } catch (e) {
+      if (attempt < this.retry.retries) {
+        const delay = Math.min(
+          this.retry.maxDelayMs,
+          this.retry.minDelayMs * this.retry.factor ** attempt
+        );
+        await sleep(delay);
+        return this.getHtml(pathOrUrl, attempt + 1);
+      }
+      if (e?.name === "AbortError") throw new HttpError("Request timeout");
+      throw new HttpError(e?.message ?? "Network error");
+    }
+  }
+  async getJson(pathOrUrl, attempt = 0) {
+    const url = this.buildURL(pathOrUrl);
+    try {
+      const res = await fetchWithTimeout(
+        url,
+        {
+          method: "GET",
+          headers: {
+            "User-Agent": this.userAgent,
+            Accept: "application/json,text/plain;q=0.9,*/*;q=0.8",
+            ...this.headers
+          }
+        },
+        this.timeoutMs
+      );
+      if (!res.ok) {
+        if (this.retry.retryOn(res.status) && attempt < this.retry.retries) {
+          const delay = Math.min(
+            this.retry.maxDelayMs,
+            this.retry.minDelayMs * this.retry.factor ** attempt
+          );
+          await sleep(delay);
+          return this.getJson(pathOrUrl, attempt + 1);
+        }
+        throw new HttpError(`HTTP ${res.status}`, res.status);
+      }
+      return await res.json();
+    } catch (e) {
+      if (attempt < this.retry.retries) {
+        const delay = Math.min(
+          this.retry.maxDelayMs,
+          this.retry.minDelayMs * this.retry.factor ** attempt
+        );
+        await sleep(delay);
+        return this.getJson(pathOrUrl, attempt + 1);
+      }
+      if (e?.name === "AbortError") throw new HttpError("Request timeout");
+      throw new HttpError(e?.message ?? "Network error");
+    }
+  }
+  async postForm(pathOrUrl, form, attempt = 0) {
+    const url = this.buildURL(pathOrUrl);
+    const usp = new URLSearchParams();
+    for (const [k, v] of Object.entries(form)) {
+      if (Array.isArray(v)) {
+        for (const item of v) usp.append(k, item);
+      } else if (v != null) {
+        usp.append(k, v);
+      }
+    }
+    const body = usp.toString();
+    try {
+      const res = await fetchWithTimeout(
+        url,
+        {
+          method: "POST",
+          headers: {
+            "User-Agent": this.userAgent,
+            "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
+            "X-Requested-With": "XMLHttpRequest",
+            Accept: "application/json, text/javascript, */*; q=0.01",
+            ...this.headers
+          },
+          body
+        },
+        this.timeoutMs
+      );
+      if (!res.ok) {
+        if (this.retry.retryOn(res.status) && attempt < this.retry.retries) {
+          const delay = Math.min(
+            this.retry.maxDelayMs,
+            this.retry.minDelayMs * this.retry.factor ** attempt
+          );
+          await sleep(delay);
+          return this.postForm(pathOrUrl, form, attempt + 1);
+        }
+        throw new HttpError(`HTTP ${res.status}`, res.status);
+      }
+      const ct = res.headers.get("content-type") || "";
+      if (ct.includes("application/json") || ct.includes("text/javascript")) {
+        return await res.json();
+      }
+      const text = await res.text();
+      try {
+        return JSON.parse(text);
+      } catch {
+        return text;
+      }
+    } catch (e) {
+      if (attempt < this.retry.retries) {
+        const delay = Math.min(
+          this.retry.maxDelayMs,
+          this.retry.minDelayMs * this.retry.factor ** attempt
+        );
+        await sleep(delay);
+        return this.postForm(pathOrUrl, form, attempt + 1);
+      }
+      if (e?.name === "AbortError") throw new HttpError("Request timeout");
+      throw new HttpError(e?.message ?? "Network error");
+    }
+  }
+};
+
+// src/client-core.ts
+var DEFAULT_HEADERS = {
+  Referer: "https://multporn.net",
+  Origin: "https://multporn.net",
+  Accept: "*/*",
+  "User-Agent": "Mozilla/5.0 (Linux; Android 12; Pixel 5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0 Mobile Safari/537.36"
+};
+function absolutize(base, href) {
+  if (!href) return void 0;
+  try {
+    if (href.startsWith("//")) return new URL("https:" + href).href;
+    return new URL(href, base).href;
+  } catch {
+    return void 0;
+  }
+}
+function looksLikeListingUrl(u) {
+  return /\/(comics|manga|munga|pictures|video|gay_porn_comics|hentai_manga)\//i.test(u);
+}
+function shouldSkipThumb(u) {
+  if (!u) return true;
+  return /(logo|avatar|sprite|icon|favicon)/i.test(u);
+}
+var MultpornClientCore = class {
+  http;
+  baseURL;
+  dom;
+  constructor(opts) {
+    this.baseURL = (opts.baseURL ?? "https://multporn.net").replace(/\/+$/, "");
+    this.http = new HttpClient({
+      baseURL: this.baseURL,
+      headers: { ...DEFAULT_HEADERS, ...opts.headers ?? {} },
+      timeoutMs: opts.timeoutMs ?? 15e3,
+      retry: opts.retry,
+      userAgent: opts.userAgent
+    });
+    this.dom = opts.dom;
+  }
+  text(el) {
+    return this.dom.text(el);
+  }
+  attr(el, n) {
+    return this.dom.attr(el, n) ?? "";
+  }
+  pickImg(el) {
+    if (!el) return void 0;
+    const inNode = el.querySelector?.("img") ?? null;
+    const imgEl = inNode || el;
+    const src = this.attr(imgEl, "data-src") || this.attr(imgEl, "data-original") || this.attr(imgEl, "src");
+    return absolutize(this.baseURL, src);
+  }
+  parseListing(html) {
+    const doc = this.dom.parse(html);
+    const root = doc.documentElement ?? doc;
+    const anchors = this.dom.qsa(root, "a[href]");
+    const seen = /* @__PURE__ */ new Set();
+    const out = [];
+    for (const a of anchors) {
+      const href = this.attr(a, "href");
+      const url = absolutize(this.baseURL, href);
+      if (!url || !looksLikeListingUrl(url)) continue;
+      if (seen.has(url)) continue;
+      const img = this.pickImg(a) || this.pickImg(this.dom.closest(a, "figure")) || this.pickImg(this.dom.closest(a, ".thumb")) || this.pickImg(a.parentNode);
+      const title = this.attr(a, "title") || this.text(a);
+      if (!title) continue;
+      const thumb = shouldSkipThumb(img) ? void 0 : img;
+      out.push({ title, url, thumb });
+      seen.add(url);
+    }
+    return out;
+  }
+  parseHasNext(html) {
+    const doc = this.dom.parse(html);
+    const root = doc.documentElement ?? doc;
+    if (this.dom.qs(root, 'a[rel="next"]')) return true;
+    const pager = this.dom.qs(root, ".pager, .pagination, nav[role='navigation']");
+    if (pager) {
+      const next = this.dom.qs(
+        pager,
+        'a[rel="next"], a.next, li.next a, a[title*="\u0421\u043B\u0435\u0434"], a[aria-label*="Next"]'
+      );
+      if (next) return true;
+    }
+    return /\bpage=\d+\b/i.test(html);
+  }
+  buildListURL(path, page = 0, letter) {
+    if (!path) {
+      const u2 = new URL(this.baseURL);
+      if (page > 0) u2.searchParams.set("page", String(page));
+      return u2.href;
+    }
+    const u = new URL(path.startsWith("/") ? path : "/" + path, this.baseURL);
+    if (page > 0) u.searchParams.set("page", String(page));
+    if (letter) u.searchParams.set("letter", letter);
+    return u.href;
+  }
+  // -------- Listing
+  async latest(page = 0, params) {
+    return this.listByPath(void 0, page, params);
+  }
+  async listByPath(path, page = 0, params) {
+    const url = this.buildListURL(path, page, params?.letter);
+    const html = await this.http.getHtml(url);
+    const items = this.parseListing(html);
+    const hasNext = this.parseHasNext(html);
+    return { items, page, hasNext, totalPages: hasNext ? page + 2 : page + 1 };
+  }
+  // -------- Search
+  async search(q, page = 0) {
+    const u = new URL("/search", this.baseURL);
+    u.searchParams.set("search", q);
+    if (page > 0) u.searchParams.set("page", String(page));
+    const html = await this.http.getHtml(u.href);
+    const items = this.parseListing(html);
+    const hasNext = this.parseHasNext(html);
+    return { items, page, hasNext, totalPages: hasNext ? page + 2 : page + 1 };
+  }
+  // -------- Post
+  parsePost(html, url) {
+    const doc = this.dom.parse(html);
+    const root = doc.documentElement ?? doc;
+    const title = this.text(this.dom.qs(root, "h1")) || this.attr(this.dom.qs(root, 'meta[property="og:title"]'), "content") || "\u0411\u0435\u0437 \u043D\u0430\u0437\u0432\u0430\u043D\u0438\u044F";
+    const imgEls = this.dom.qsa(root, "img");
+    const imgSet = /* @__PURE__ */ new Set();
+    for (const el of imgEls) {
+      const src = absolutize(
+        this.baseURL,
+        this.attr(el, "data-src") || this.attr(el, "data-original") || this.attr(el, "src")
+      );
+      if (!src || /\b(logo|sprite|icon|favicon)\b/i.test(src)) continue;
+      imgSet.add(src);
+    }
+    const images = Array.from(imgSet);
+    const tags = [];
+    const tagEls = this.dom.qsa(root, 'a[href*="/tags/"], .tags a, .field-name-field-tags a');
+    for (const t of tagEls) {
+      const txt = this.text(t);
+      if (txt) tags.push(txt);
+    }
+    return {
+      url,
+      title,
+      images,
+      tags,
+      author: null
+    };
+  }
+  async getPost(urlOrSlug) {
+    const url = absolutize(this.baseURL, urlOrSlug) ?? new URL(urlOrSlug, this.baseURL).href;
+    const html = await this.http.getHtml(url);
+    return this.parsePost(html, url);
+  }
+  // -------- Smart resolve
+  async resolveSmart(urlOrSlug, _opts) {
+    const url = absolutize(this.baseURL, urlOrSlug) ?? new URL(urlOrSlug, this.baseURL).href;
+    const html = await this.http.getHtml(url);
+    const doc = this.dom.parse(html);
+    const articleImgs = this.dom.qsa(doc.documentElement ?? doc, "article img");
+    if (articleImgs.length >= 2) {
+      const post = this.parsePost(html, url);
+      return {
+        route: "viewer",
+        data: {
+          absoluteUrl: url,
+          viewer: {
+            kind: "images",
+            meta: {
+              nodeId: null,
+              fieldSys: null,
+              title: post.title,
+              kind: "images",
+              breadcrumbs: [],
+              authors: [],
+              sections: [],
+              tags: [],
+              characters: [],
+              userTags: []
+            },
+            images: post.images.map((u) => ({ original: u }))
+          }
+        }
+      };
+    }
+    const items = this.parseListing(html);
+    const hasNext = this.parseHasNext(html);
+    return {
+      route: "listing",
+      data: {
+        page: 0,
+        items,
+        hasNext,
+        absoluteUrl: url,
+        path: new URL(url).pathname
+      }
+    };
+  }
+  // -------- Alphabet (best effort)
+  async alphabetLetters(section) {
+    const path = section === "manga" ? "/munga" : `/${section}`;
+    const html = await this.http.getHtml(path);
+    const doc = this.dom.parse(html);
+    const root = doc.documentElement ?? doc;
+    const letters = [];
+    const els = this.dom.qsa(
+      root,
+      ".alphabet a, .alphabet__item a, .letters a, a[href*='letter=']"
+    );
+    for (const a of els) {
+      const label = this.text(a) || this.attr(a, "data-letter");
+      if (!label) continue;
+      const href = this.attr(a, "href");
+      letters.push({ label, value: label, href });
+    }
+    if (!letters.length) {
+      return "ABCDEFGHIJKLMNOPQRSTUVWXYZ".split("").map((c) => ({ label: c, value: c, href: "" }));
+    }
+    return letters;
+  }
+  async alphabet(section, letter, page = 0) {
+    const path = section === "manga" ? "/munga" : `/${section}`;
+    return this.listByPath(path, page, { letter });
+  }
+  // -------- Updates (views/ajax) — best effort
+  // ВАЖНО: чтобы не ловить TS2411, не используем индексную сигнатуру с строгим 'string|number'.
+  // Вход — Partial (значит, значения могут быть undefined), а отправляем — отфильтрованный Record.
+  async updates(params) {
+    const filtered = Object.fromEntries(
+      Object.entries(params ?? {}).filter(([, v]) => v !== void 0)
+    );
+    const p = { view_name: params?.view_name ?? "new_mini", ...params };
+    const json = await this.http.postForm("/views/ajax", p);
+    const raw = typeof json === "string" ? json : JSON.stringify(json);
+    const items = this.parseListing(raw);
+    return { items, first: 0, last: items.length, html: raw, viewName: String(p.view_name) };
+  }
+  async viewUpdates(viewName, params) {
+    return this.updates({ view_name: viewName, ...params || {} });
+  }
+};
+export {
+  MultpornClientCore as MultpornClient
+};