coomer-downloader 3.0.10 → 3.1.0

package/dist/index.js

@@ -32,12 +32,12 @@ function tryFixCoomerUrl(url, attempts) {
 }
 async function getUserProfileAPI(user) {
   const url = `${user.domain}/api/v1/${user.service}/user/${user.id}/profile`;
-  const result = await fetch_(url).then((r) => r.json());
+  const result = await fetchWithGlobalHeader(url).then((r) => r.json());
   return result;
 }
 async function getUserPostsAPI(user, offset) {
   const url = `${user.domain}/api/v1/${user.service}/user/${user.id}/posts?o=${offset}`;
-  const posts = await fetch_(url).then((r) => r.json());
+  const posts = await fetchWithGlobalHeader(url).then((r) => r.json());
   return posts;
 }
 async function getUserFiles(user, mediaType) {
@@ -95,10 +95,50 @@ function mkdir(filepath) {
   }
 }
 
+// src/utils/promise.ts
+async function sleep(time) {
+  return new Promise((resolve) => setTimeout(resolve, time));
+}
+var PromiseRetry = class _PromiseRetry {
+  retries;
+  delay;
+  callback;
+  constructor(options) {
+    this.retries = options.retries || 3;
+    this.delay = options.delay || 1e3;
+    this.callback = options.callback;
+  }
+  async execute(fn) {
+    let retries = this.retries;
+    while (true) {
+      try {
+        return await fn();
+      } catch (error) {
+        if (retries <= 0) {
+          throw error;
+        }
+        if (this.callback) {
+          const res = this.callback(retries, error);
+          if (res) {
+            const { newRetries } = res;
+            if (newRetries === 0) throw error;
+            this.retries = newRetries || retries;
+          }
+        }
+        await sleep(this.delay);
+        retries--;
+      }
+    }
+  }
+  static create(options) {
+    return new _PromiseRetry(options);
+  }
+};
+
 // src/utils/requests.ts
 import { CookieAgent } from "http-cookie-agent/undici";
 import { CookieJar } from "tough-cookie";
-import { fetch, getGlobalDispatcher, interceptors, setGlobalDispatcher } from "undici";
+import { fetch, interceptors, setGlobalDispatcher } from "undici";
 function setCookieJarDispatcher() {
   const jar = new CookieJar();
   const agent = new CookieAgent({ cookies: { jar } }).compose(interceptors.retry()).compose(interceptors.redirect({ maxRedirections: 3 }));
@@ -114,7 +154,7 @@ function setGlobalHeaders(headers) {
     HeadersDefault.set(k, headers[k]);
   });
 }
-function fetch_(url) {
+function fetchWithGlobalHeader(url) {
   const requestHeaders = new Headers(HeadersDefault);
   return fetch(url, { headers: requestHeaders });
 }
@@ -125,7 +165,7 @@ function fetchByteRange(url, downloadedSize) {
 }
 
 // src/utils/timer.ts
-var Timer = class {
+var Timer = class _Timer {
   constructor(timeout = 1e4, timeoutCallback) {
     this.timeout = timeout;
     this.timeoutCallback = timeoutCallback;
@@ -133,7 +173,10 @@ var Timer = class {
   }
   timer = void 0;
   start() {
-    this.timer = setTimeout(this.timeoutCallback, this.timeout);
+    this.timer = setTimeout(() => {
+      this.stop();
+      this.timeoutCallback();
+    }, this.timeout);
     return this;
   }
   stop() {
@@ -148,19 +191,27 @@ var Timer = class {
     this.start();
     return this;
   }
+  static withSignal(timeout, message) {
+    const controller = new AbortController();
+    const callback = () => {
+      controller.abort(message);
+    };
+    const timer = new _Timer(timeout, callback).start();
+    return {
+      timer,
+      signal: controller.signal
+    };
+  }
 };
 
 // src/utils/downloader.ts
 var subject = new Subject();
 var CHUNK_TIMEOUT = 3e4;
-var DOWNLOAD_ATTEMPTS = 7;
-async function downloadStream(file, stream) {
-  subject.next({ type: "CHUNK_DOWNLOADING_STARTED", file });
+var CHUNK_FETCH_RETRIES = 5;
+var FETCH_RETRIES = 7;
+async function fetchStream(file, stream) {
+  const { timer, signal } = Timer.withSignal(CHUNK_TIMEOUT, "CHUNK_TIMEOUT");
   const fileStream = fs2.createWriteStream(file.filepath, { flags: "a" });
-  const controller = new AbortController();
-  const timer = new Timer(CHUNK_TIMEOUT, () => {
-    controller.abort("Stream is stuck.");
-  }).start();
   const progressStream = new Transform({
     transform(chunk, _encoding, callback) {
       this.push(chunk);
@@ -170,71 +221,82 @@ async function downloadStream(file, stream) {
       callback();
     }
   });
-  await pipeline(stream, progressStream, fileStream, { signal: controller.signal });
-  timer.stop();
-  subject.next({ type: "FILE_DOWNLOADING_FINISHED" });
-}
-function handleFetchError(error, file, attempts) {
-  const url = file?.url;
-  if (/coomer|kemono/.test(url)) {
-    file.url = tryFixCoomerUrl(url, attempts);
-  }
-  throw error;
-}
-async function downloadFile(file, attempts = DOWNLOAD_ATTEMPTS) {
-  const downloadedOld = file.downloaded || 0;
   try {
-    file.downloaded = await getFileSize(file.filepath);
-    const response = await fetchByteRange(file.url, file.downloaded).catch(
-      (error) => handleFetchError(error, file, --attempts)
-    );
-    if (!response?.ok && response?.status !== 416) {
-      throw new Error(`HTTP error! status: ${response?.status}`);
-    }
-    const contentLength = response.headers.get("Content-Length");
-    if (!contentLength && file.downloaded > 0) {
-      return;
-    }
-    const restFileSize = parseInt(contentLength);
-    file.size = restFileSize + file.downloaded;
-    if (file.size > file.downloaded && response.body) {
-      const stream = Readable.fromWeb(response.body);
-      await downloadStream(file, stream);
-    }
+    subject.next({ type: "CHUNK_DOWNLOADING_START", file });
+    await pipeline(stream, progressStream, fileStream, { signal });
   } catch (error) {
-    if (downloadedOld < (file.downloaded || 0)) {
-      attempts = DOWNLOAD_ATTEMPTS;
-    }
-    if (attempts < 1) {
-      console.error(file.url);
-      console.error(error);
-    } else {
-      await downloadFile(file, attempts - 1);
-    }
+    console.error(error.name === "AbortError" ? signal.reason : error);
+  } finally {
+    subject.next({ type: "CHUNK_DOWNLOADING_END", file });
   }
 }
+async function downloadFile(file) {
+  file.downloaded = await getFileSize(file.filepath);
+  const response = await fetchByteRange(file.url, file.downloaded);
+  if (!response?.ok && response?.status !== 416) {
+    throw new Error(`HTTP error! status: ${response?.status}`);
+  }
+  const contentLength = response.headers.get("Content-Length");
+  if (!contentLength && file.downloaded > 0) {
+    return;
+  }
+  const restFileSize = parseInt(contentLength);
+  file.size = restFileSize + file.downloaded;
+  if (file.size > file.downloaded && response.body) {
+    const stream = Readable.fromWeb(response.body);
+    const sizeOld = file.downloaded;
+    await PromiseRetry.create({
+      retries: CHUNK_FETCH_RETRIES,
+      callback: () => {
+        if (sizeOld !== file.downloaded) {
+          return { newRetries: 5 };
+        }
+      }
+    }).execute(async () => await fetchStream(file, stream));
+  }
+  subject.next({ type: "FILE_DOWNLOADING_END" });
+}
 async function downloadFiles(data, downloadDir) {
   mkdir(downloadDir);
-  subject.next({ type: "FILES_DOWNLOADING_STARTED", filesCount: data.length });
-  for (const [index, file] of data.entries()) {
+  subject.next({ type: "FILES_DOWNLOADING_START", filesCount: data.length });
+  for (const [_, file] of data.entries()) {
     file.filepath = path.join(downloadDir, file.name);
-    subject.next({ type: "FILE_DOWNLOADING_STARTED", index });
-    await downloadFile(file);
+    subject.next({ type: "FILE_DOWNLOADING_START" });
+    await PromiseRetry.create({
+      retries: FETCH_RETRIES,
+      callback: (retries) => {
+        if (/coomer|kemono/.test(file.url)) {
+          file.url = tryFixCoomerUrl(file.url, retries);
+        }
+      }
+    }).execute(async () => await downloadFile(file));
+    subject.next({ type: "FILE_DOWNLOADING_END" });
   }
-  subject.next({ type: "FILES_DOWNLOADING_STARTED" });
+  subject.next({ type: "FILES_DOWNLOADING_END" });
 }
 
 // src/utils/filters.ts
 var isImage = (name) => /\.(jpg|jpeg|png|gif|bmp|tiff|webp|avif)$/i.test(name);
 var isVideo = (name) => /\.(mp4|m4v|avi|mov|mkv|webm|flv|wmv|mpeg|mpg|3gp)$/i.test(name);
 var testMediaType = (name, type) => type === "all" ? true : type === "image" ? isImage(name) : isVideo(name);
+function includesAllWords(str, words) {
+  if (!words.length) return true;
+  return words.every((w) => str.includes(w));
+}
+function includesNoWords(str, words) {
+  if (!words.length) return true;
+  return words.every((w) => !str.includes(w));
+}
+function parseQuery(query) {
+  return query.split(",").map((x) => x.toLowerCase().trim()).filter((_) => _);
+}
+function filterString(text, include, exclude) {
+  return includesAllWords(text, parseQuery(include)) && includesNoWords(text, parseQuery(exclude));
+}
 function filterKeywords(files, include, exclude) {
-  const incl = include.split(",").map((x) => x.toLowerCase().trim());
-  const excl = exclude.split(",").map((x) => x.toLowerCase().trim());
-  const isValid = (text) => incl.some((e) => text.includes(e)) && (!exclude.trim().length || excl.every((e) => !text.includes(e)));
   return files.filter((f) => {
     const text = `${f.name || ""} ${f.content || ""}`.toLowerCase();
-    return isValid(text);
+    return filterString(text, include, exclude);
   });
 }
 
@@ -267,33 +329,37 @@ function createMultibar() {
   let bar;
   let minibar;
   let filename;
+  let index = 0;
   subject.subscribe({
-    next: ({ type, filesCount, index, file }) => {
+    next: ({ type, filesCount, file }) => {
       switch (type) {
-        case "FILES_DOWNLOADING_STARTED":
+        case "FILES_DOWNLOADING_START":
           bar?.stop();
           bar = multibar.create(filesCount, 0);
           break;
-        case "FILES_DOWNLOADING_FINISHED":
+        case "FILES_DOWNLOADING_END":
           bar?.stop();
           break;
-        case "FILE_DOWNLOADING_STARTED":
-          bar?.update(index + 1, { filename: "Downloaded files", size: "" });
+        case "FILE_DOWNLOADING_START":
+          bar?.update(++index, { filename: "Downloaded files", size: "" });
+          break;
+        case "FILE_DOWNLOADING_END":
+          multibar.remove(minibar);
           break;
-        case "CHUNK_DOWNLOADING_STARTED":
+        case "CHUNK_DOWNLOADING_START":
           multibar?.remove(minibar);
           filename = formatNameStdout(file?.filepath);
           minibar = multibar.create(b2mb(file?.size), b2mb(file?.downloaded));
           break;
-        case "FILE_DOWNLOADING_FINISHED":
-          multibar.remove(minibar);
-          break;
         case "CHUNK_DOWNLOADING_UPDATE":
           minibar?.update(b2mb(file?.downloaded), {
             filename,
             size: "mb"
           });
           break;
+        case "CHUNK_DOWNLOADING_END":
+          multibar?.remove(minibar);
+          break;
         default:
           break;
       }
@@ -515,7 +581,7 @@ async function run() {
   const { url, dir, media, include, exclude, skip } = argumentHander();
   const { dirName, files } = await apiHandler(url, media);
   const downloadDir = dir === "./" ? path2.resolve(dir, dirName) : path2.join(os.homedir(), path2.join(dir, dirName));
-  const filteredFiles = filterKeywords(files, include, exclude).slice(skip);
+  const filteredFiles = filterKeywords(files.slice(skip), include, exclude);
   console.table([
     {
       found: files.length,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coomer-downloader",
-  "version": "3.0.10",
+  "version": "3.1.0",
   "author": "smartacephal",
   "license": "MIT",
   "description": "Downloads images/videos from Coomer/Kemono, Bunkr, GoFile, Reddit-NSFW user posts",

package/src/api/coomer-api.ts

@@ -1,5 +1,5 @@
 import type { ApiResult, File, MediaType } from '../types/index.js';
-import { fetch_, isImage, setGlobalHeaders, testMediaType } from '../utils/index.js';
+import { fetchWithGlobalHeader, isImage, setGlobalHeaders, testMediaType } from '../utils/index.js';
 
 type CoomerUser = { domain: string; service: string; id: string; name?: string };
 type CoomerUserApi = { name: string };
@@ -29,13 +29,13 @@ export function tryFixCoomerUrl(url: string, attempts: number) {
 
 async function getUserProfileAPI(user: CoomerUser): Promise<CoomerUserApi> {
   const url = `${user.domain}/api/v1/${user.service}/user/${user.id}/profile`;
-  const result = await fetch_(url).then((r) => r.json());
+  const result = await fetchWithGlobalHeader(url).then((r) => r.json());
   return result as CoomerUserApi;
 }
 
 async function getUserPostsAPI(user: CoomerUser, offset: number): Promise<CoomerPost[]> {
   const url = `${user.domain}/api/v1/${user.service}/user/${user.id}/posts?o=${offset}`;
-  const posts = await fetch_(url).then((r) => r.json());
+  const posts = await fetchWithGlobalHeader(url).then((r) => r.json());
   return posts as CoomerPost[];
 }
 

package/src/index.ts

@@ -15,7 +15,7 @@ async function run() {
   const downloadDir =
     dir === './' ? path.resolve(dir, dirName) : path.join(os.homedir(), path.join(dir, dirName));
 
-  const filteredFiles = filterKeywords(files, include, exclude).slice(skip);
+  const filteredFiles = filterKeywords(files.slice(skip), include, exclude);
 
   console.table([
     {
@@ -29,6 +29,7 @@ async function run() {
   setGlobalHeaders({ Referer: url });
 
   createMultibar();
+
   await downloadFiles(filteredFiles, downloadDir);
 
   process.kill(process.pid, 'SIGINT');

package/src/utils/downloader.ts

@@ -6,24 +6,21 @@ import { Subject } from 'rxjs';
 import { tryFixCoomerUrl } from '../api/coomer-api';
 import type { DownloaderSubject, File } from '../types';
 import { getFileSize, mkdir } from './files';
+import { PromiseRetry } from './promise';
 import { fetchByteRange } from './requests';
 import { Timer } from './timer';
 
 export const subject = new Subject<DownloaderSubject>();
 
 const CHUNK_TIMEOUT = 30_000;
-const DOWNLOAD_ATTEMPTS = 7;
+const CHUNK_FETCH_RETRIES = 5;
+const FETCH_RETRIES = 7;
 
-async function downloadStream(file: File, stream: Readable): Promise<void> {
-  subject.next({ type: 'CHUNK_DOWNLOADING_STARTED', file });
+async function fetchStream(file: File, stream: Readable): Promise<void> {
+  const { timer, signal } = Timer.withSignal(CHUNK_TIMEOUT, 'CHUNK_TIMEOUT');
 
   const fileStream = fs.createWriteStream(file.filepath as string, { flags: 'a' });
 
-  const controller = new AbortController();
-  const timer = new Timer(CHUNK_TIMEOUT, () => {
-    controller.abort('Stream is stuck.');
-  }).start();
-
   const progressStream = new Transform({
     transform(chunk, _encoding, callback) {
       this.push(chunk);
@@ -34,68 +31,72 @@ async function downloadStream(file: File, stream: Readable): Promise<void> {
     },
   });
 
-  await pipeline(stream, progressStream, fileStream, { signal: controller.signal });
-  timer.stop();
-  subject.next({ type: 'FILE_DOWNLOADING_FINISHED' });
-}
-
-function handleFetchError(error: Error, file: File, attempts: number): void {
-  const url = file?.url as string;
-  if (/coomer|kemono/.test(url)) {
-    file.url = tryFixCoomerUrl(url, attempts);
+  try {
+    subject.next({ type: 'CHUNK_DOWNLOADING_START', file });
+    await pipeline(stream, progressStream, fileStream, { signal });
+  } catch (error) {
+    console.error((error as Error).name === 'AbortError' ? signal.reason : error);
+  } finally {
+    subject.next({ type: 'CHUNK_DOWNLOADING_END', file });
   }
-  throw error;
 }
 
-async function downloadFile(file: File, attempts = DOWNLOAD_ATTEMPTS): Promise<void> {
-  const downloadedOld = file.downloaded || 0;
-  try {
-    file.downloaded = await getFileSize(file.filepath as string);
-
-    const response = await fetchByteRange(file.url, file.downloaded).catch((error) =>
-      handleFetchError(error, file, --attempts),
-    );
+async function downloadFile(file: File): Promise<void> {
+  file.downloaded = await getFileSize(file.filepath as string);
 
-    if (!response?.ok && response?.status !== 416) {
-      throw new Error(`HTTP error! status: ${response?.status}`);
-    }
+  const response = await fetchByteRange(file.url, file.downloaded);
 
-    const contentLength = response.headers.get('Content-Length') as string;
+  if (!response?.ok && response?.status !== 416) {
+    throw new Error(`HTTP error! status: ${response?.status}`);
+  }
 
-    if (!contentLength && file.downloaded > 0) {
-      return;
-    }
+  const contentLength = response.headers.get('Content-Length') as string;
 
-    const restFileSize = parseInt(contentLength);
-    file.size = restFileSize + file.downloaded;
+  if (!contentLength && file.downloaded > 0) {
+    return;
+  }
 
-    if (file.size > file.downloaded && response.body) {
-      const stream = Readable.fromWeb(response.body);
-      await downloadStream(file, stream);
-    }
-  } catch (error) {
-    if (downloadedOld < (file.downloaded || 0)) {
-      attempts = DOWNLOAD_ATTEMPTS;
-    }
-    if (attempts < 1) {
-      console.error(file.url);
-      console.error(error);
-    } else {
-      await downloadFile(file, attempts - 1);
-    }
+  const restFileSize = parseInt(contentLength);
+  file.size = restFileSize + file.downloaded;
+
+  if (file.size > file.downloaded && response.body) {
+    const stream = Readable.fromWeb(response.body);
+    const sizeOld = file.downloaded;
+
+    await PromiseRetry.create({
+      retries: CHUNK_FETCH_RETRIES,
+      callback: () => {
+        if (sizeOld !== file.downloaded) {
+          return { newRetries: 5 };
+        }
+      },
+    }).execute(async () => await fetchStream(file, stream));
   }
+
+  subject.next({ type: 'FILE_DOWNLOADING_END' });
 }
 
 export async function downloadFiles(data: File[], downloadDir: string): Promise<void> {
   mkdir(downloadDir);
 
-  subject.next({ type: 'FILES_DOWNLOADING_STARTED', filesCount: data.length });
+  subject.next({ type: 'FILES_DOWNLOADING_START', filesCount: data.length });
 
-  for (const [index, file] of data.entries()) {
+  for (const [_, file] of data.entries()) {
     file.filepath = path.join(downloadDir, file.name);
-    subject.next({ type: 'FILE_DOWNLOADING_STARTED', index });
-    await downloadFile(file);
+
+    subject.next({ type: 'FILE_DOWNLOADING_START' });
+
+    await PromiseRetry.create({
+      retries: FETCH_RETRIES,
+      callback: (retries) => {
+        if (/coomer|kemono/.test(file.url)) {
+          file.url = tryFixCoomerUrl(file.url, retries);
+        }
+      },
+    }).execute(async () => await downloadFile(file));
+
+    subject.next({ type: 'FILE_DOWNLOADING_END' });
   }
 
-  subject.next({ type: 'FILES_DOWNLOADING_STARTED' });
+  subject.next({ type: 'FILES_DOWNLOADING_END' });
 }

package/src/utils/filters.ts

@@ -8,16 +8,30 @@ export const isVideo = (name: string) =>
 export const testMediaType = (name: string, type: MediaType) =>
   type === 'all' ? true : type === 'image' ? isImage(name) : isVideo(name);
 
-export function filterKeywords(files: File[], include: string, exclude: string) {
-  const incl = include.split(',').map((x) => x.toLowerCase().trim());
-  const excl = exclude.split(',').map((x) => x.toLowerCase().trim());
+function includesAllWords(str: string, words: string[]) {
+  if (!words.length) return true;
+  return words.every((w) => str.includes(w));
+}
+
+function includesNoWords(str: string, words: string[]) {
+  if (!words.length) return true;
+  return words.every((w) => !str.includes(w));
+}
 
-  const isValid = (text: string) =>
-    incl.some((e) => text.includes(e)) &&
-    (!exclude.trim().length || excl.every((e) => !text.includes(e)));
+function parseQuery(query: string) {
+  return query
+    .split(',')
+    .map((x) => x.toLowerCase().trim())
+    .filter((_) => _);
+}
+
+function filterString(text: string, include: string, exclude: string): boolean {
+  return includesAllWords(text, parseQuery(include)) && includesNoWords(text, parseQuery(exclude));
+}
 
+export function filterKeywords(files: File[], include: string, exclude: string) {
   return files.filter((f) => {
     const text = `${f.name || ''} ${f.content || ''}`.toLowerCase();
-    return isValid(text);
+    return filterString(text, include, exclude);
   });
 }

package/src/utils/index.ts

@@ -2,5 +2,10 @@ export { downloadFiles } from './downloader';
 export { getFileSize, mkdir } from './files';
 export { filterKeywords, isImage, isVideo, testMediaType } from './filters';
 export { createMultibar } from './multibar';
-export { fetch_, fetchByteRange, HeadersDefault, setGlobalHeaders } from './requests';
+export {
+  fetchByteRange,
+  fetchWithGlobalHeader,
+  HeadersDefault,
+  setGlobalHeaders,
+} from './requests';
 export { b2mb } from './strings';

package/src/utils/multibar.ts

@@ -1,8 +1,8 @@
-import { MultiBar, type SingleBar } from 'cli-progress';
+import { MultiBar, type Options, type SingleBar } from 'cli-progress';
 import { subject } from './downloader';
 import { b2mb, formatNameStdout } from './strings';
 
-const config = {
+const config: Options = {
   clearOnComplete: true,
   gracefulExit: true,
   autopadding: true,
@@ -10,44 +10,39 @@ const config = {
   format: '{percentage}% | {filename} | {value}/{total}{size}',
 };
 
-// interface IBarState {
-//   totalFiles: number;
-//   totalDownloadedFiles: number;
-//   filesInProcess: File[];
-// }
-
 export function createMultibar() {
   const multibar = new MultiBar(config);
   let bar: SingleBar;
   let minibar: SingleBar;
   let filename: string;
+  let index = 0;
 
   subject.subscribe({
-    next: ({ type, filesCount, index, file }) => {
+    next: ({ type, filesCount, file }) => {
       switch (type) {
-        case 'FILES_DOWNLOADING_STARTED':
+        case 'FILES_DOWNLOADING_START':
           bar?.stop();
           bar = multibar.create(filesCount as number, 0);
           break;
 
-        case 'FILES_DOWNLOADING_FINISHED':
+        case 'FILES_DOWNLOADING_END':
           bar?.stop();
           break;
 
-        case 'FILE_DOWNLOADING_STARTED':
-          bar?.update((index as number) + 1, { filename: 'Downloaded files', size: '' });
+        case 'FILE_DOWNLOADING_START':
+          bar?.update(++index, { filename: 'Downloaded files', size: '' });
           break;
 
-        case 'CHUNK_DOWNLOADING_STARTED':
+        case 'FILE_DOWNLOADING_END':
+          multibar.remove(minibar);
+          break;
+
+        case 'CHUNK_DOWNLOADING_START':
           multibar?.remove(minibar);
           filename = formatNameStdout(file?.filepath as string);
           minibar = multibar.create(b2mb(file?.size as number), b2mb(file?.downloaded as number));
           break;
 
-        case 'FILE_DOWNLOADING_FINISHED':
-          multibar.remove(minibar);
-          break;
-
         case 'CHUNK_DOWNLOADING_UPDATE':
           minibar?.update(b2mb(file?.downloaded as number), {
             filename: filename as string,
@@ -55,6 +50,10 @@ export function createMultibar() {
           });
           break;
 
+        case 'CHUNK_DOWNLOADING_END':
+          multibar?.remove(minibar);
+          break;
+
         default:
           break;
       }

package/src/utils/promise.ts

@@ -0,0 +1,53 @@
+export async function sleep(time: number) {
+  return new Promise((resolve) => setTimeout(resolve, time));
+}
+
+type PromiseRetryCallback = (retries: number, error: Error) => void | { newRetries?: number };
+
+interface PromiseRetryOptions {
+  retries?: number;
+  callback?: PromiseRetryCallback;
+  delay?: number;
+}
+
+export class PromiseRetry {
+  private retries: number;
+  private delay: number;
+  private callback?: PromiseRetryCallback;
+
+  constructor(options: PromiseRetryOptions) {
+    this.retries = options.retries || 3;
+    this.delay = options.delay || 1000;
+    this.callback = options.callback;
+  }
+
+  async execute(fn: () => Promise<void>) {
+    let retries = this.retries;
+
+    while (true) {
+      try {
+        return await fn();
+      } catch (error) {
+        if (retries <= 0) {
+          throw error;
+        }
+
+        if (this.callback) {
+          const res = this.callback(retries, error as Error);
+          if (res) {
+            const { newRetries } = res;
+            if (newRetries === 0) throw error;
+            this.retries = newRetries || retries;
+          }
+        }
+
+        await sleep(this.delay);
+        retries--;
+      }
+    }
+  }
+
+  static create(options: PromiseRetryOptions) {
+    return new PromiseRetry(options);
+  }
+}

package/src/utils/requests.ts

@@ -1,6 +1,6 @@
 import { CookieAgent } from 'http-cookie-agent/undici';
 import { CookieJar } from 'tough-cookie';
-import { fetch, getGlobalDispatcher, interceptors, setGlobalDispatcher } from 'undici';
+import { fetch, interceptors, setGlobalDispatcher } from 'undici';
 
 function setCookieJarDispatcher() {
   const jar = new CookieJar();
@@ -12,20 +12,6 @@ function setCookieJarDispatcher() {
 
 setCookieJarDispatcher();
 
-export function setRetryDispatcher(maxRetries = 3) {
-  setGlobalDispatcher(
-    getGlobalDispatcher().compose(
-      interceptors.retry({
-        maxRetries,
-        // minTimeout: 1000,
-        // maxTimeout: 10000,
-        timeoutFactor: 2,
-        retryAfter: true,
-      }),
-    ),
-  );
-}
-
 export const HeadersDefault = new Headers({
   accept: 'application/json, text/css',
   'User-Agent':
@@ -38,7 +24,7 @@ export function setGlobalHeaders(headers: Record<string, string>) {
   });
 }
 
-export function fetch_(url: string) {
+export function fetchWithGlobalHeader(url: string) {
   const requestHeaders = new Headers(HeadersDefault);
   return fetch(url, { headers: requestHeaders });
 }

package/src/utils/strings.ts

@@ -16,6 +16,6 @@ export function formatNameStdout(pathname: string) {
   const consoleWidth = process.stdout.columns;
   const width = Math.max((consoleWidth / 2) | 0, 40);
   if (name.length < width) return name.trim();
-  const result = `${name.slice(0,width-15)} ... ${name.slice(-10)}`.replace(/ +/g, ' ');
+  const result = `${name.slice(0, width - 15)} ... ${name.slice(-10)}`.replace(/ +/g, ' ');
   return result;
 }

package/src/utils/timer.ts

@@ -9,7 +9,10 @@ export class Timer {
   }
 
   start() {
-    this.timer = setTimeout(this.timeoutCallback, this.timeout);
+    this.timer = setTimeout(() => {
+      this.stop();
+      this.timeoutCallback();
+    }, this.timeout);
     return this;
   }
 
@@ -26,4 +29,19 @@ export class Timer {
     this.start();
     return this;
   }
+
+  static withSignal(timeout?: number, message?: string) {
+    const controller = new AbortController();
+
+    const callback = () => {
+      controller.abort(message);
+    };
+
+    const timer = new Timer(timeout, callback).start();
+
+    return {
+      timer,
+      signal: controller.signal,
+    };
+  }
 }

package/src/utils/file.ts

@@ -1,26 +0,0 @@
-// import path from 'node:path';
-
-// class CFileList {
-//   files: CFile[];
-//   active: CFile[];
-// }
-
-// export class CFile {
-//   constructor(
-//     public name = '',
-//     public url = '',
-//     public filepath = '',
-//     public content = '',
-//     public size = 0,
-//     public downloaded = 0,
-//     public maybeFixURL?: undefined | ((url: string) => string),
-//   ) {}
-
-//   get text() {
-//     return `${this.content} ${this.name}`.toLowerCase();
-//   }
-
-//   setDir(dir: string) {
-//     this.filepath = path.join(dir, this.name);
-//   }
-// }