coomer-downloader 3.0.10 → 3.2.0

package/src/utils/file.ts

@@ -1,26 +1,75 @@
-// 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);
-//   }
-// }
+import os from 'node:os';
+import path from 'node:path';
+import type { MediaType } from '../types';
+import { filterString, testMediaType } from './filters';
+
+interface ICoomerFile {
+  name: string;
+  url: string;
+  filepath?: string;
+  size?: number;
+  downloaded?: number;
+  content?: string;
+}
+
+export class CoomerFile {
+  public state: 'downloading' | 'pause' = 'pause';
+
+  constructor(
+    public name: string,
+    public url: string,
+    public filepath?: string,
+    public size?: number,
+    public downloaded?: number,
+    public content?: string,
+  ) {}
+
+  get textContent() {
+    const text = `${this.name || ''} ${this.content || ''}`.toLowerCase();
+    return text;
+  }
+
+  public static from(f: ICoomerFile) {
+    return new CoomerFile(f.name, f.url, f.filepath, f.size, f.downloaded, f.content);
+  }
+}
+
+export class CoomerFileList {
+  public dirPath?: string;
+  public dirName?: string;
+
+  constructor(public files: CoomerFile[] = []) {}
+
+  public setDirPath(dir: string, dirName?: string) {
+    dirName = dirName || (this.dirName as string);
+
+    if (dir === './') {
+      this.dirPath = path.resolve(dir, dirName);
+    } else {
+      this.dirPath = path.join(os.homedir(), path.join(dir, dirName));
+    }
+
+    this.files.forEach((file) => {
+      file.filepath = path.join(this.dirPath as string, file.name);
+    });
+
+    return this;
+  }
+
+  public filterByText(include: string, exclude: string) {
+    this.files = this.files.filter((f) => filterString(f.textContent, include, exclude));
+    return this;
+  }
+
+  public filterByMediaType(media?: string) {
+    if (media) {
+      this.files = this.files.filter((f) => testMediaType(f.name, media as MediaType));
+    }
+    return this;
+  }
+
+  public skip(n: number) {
+    this.files = this.files.slice(n);
+    return this;
+  }
+}

package/src/utils/filters.ts

@@ -1,23 +1,34 @@
-import type { File, MediaType } from '../types';
+import type { MediaType } from '../types';
 
-export const isImage = (name: string) => /\.(jpg|jpeg|png|gif|bmp|tiff|webp|avif)$/i.test(name);
+export function isImage(name: string) {
+  return /\.(jpg|jpeg|png|gif|bmp|tiff|webp|avif)$/i.test(name);
+}
 
-export const isVideo = (name: string) =>
-  /\.(mp4|m4v|avi|mov|mkv|webm|flv|wmv|mpeg|mpg|3gp)$/i.test(name);
+export function isVideo(name: string) {
+  return /\.(mp4|m4v|avi|mov|mkv|webm|flv|wmv|mpeg|mpg|3gp)$/i.test(name);
+}
 
-export const testMediaType = (name: string, type: MediaType) =>
-  type === 'all' ? true : type === 'image' ? isImage(name) : isVideo(name);
+export function testMediaType(name: string, type: MediaType) {
+  return 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));
+}
 
-  const isValid = (text: string) =>
-    incl.some((e) => text.includes(e)) &&
-    (!exclude.trim().length || excl.every((e) => !text.includes(e)));
+function includesNoWords(str: string, words: string[]) {
+  if (!words.length) return true;
+  return words.every((w) => !str.includes(w));
+}
+
+function parseQuery(query: string) {
+  return query
+    .split(',')
+    .map((x) => x.toLowerCase().trim())
+    .filter((_) => _);
+}
 
-  return files.filter((f) => {
-    const text = `${f.name || ''} ${f.content || ''}`.toLowerCase();
-    return isValid(text);
-  });
+export function filterString(text: string, include: string, exclude: string): boolean {
+  return includesAllWords(text, parseQuery(include)) && includesNoWords(text, parseQuery(exclude));
 }

package/src/utils/index.ts

@@ -1,6 +1,11 @@
-export { downloadFiles } from './downloader';
-export { getFileSize, mkdir } from './files';
-export { filterKeywords, isImage, isVideo, testMediaType } from './filters';
+export { Downloader } from './downloader';
+export { isImage, isVideo, testMediaType } from './filters';
+export { getFileSize, mkdir } from './io';
 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 { subject } from './downloader';
+import { MultiBar, type Options, type SingleBar } from 'cli-progress';
+import type { Downloader } 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() {
+export function createMultibar(downloader: Downloader) {
   const multibar = new MultiBar(config);
   let bar: SingleBar;
   let minibar: SingleBar;
   let filename: string;
+  let index = 0;
 
-  subject.subscribe({
-    next: ({ type, filesCount, index, file }) => {
+  downloader.subject.subscribe({
+    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

@@ -2,20 +2,11 @@ export function b2mb(bytes: number) {
   return Number.parseFloat((bytes / 1048576).toFixed(2));
 }
 
-export function sanitizeString(str: string) {
-  return (
-    str
-      .match(/(\w| |-)/g)
-      ?.join('')
-      .replace(/ +/g, ' ') || ''
-  );
-}
-
 export function formatNameStdout(pathname: string) {
   const name = pathname.split('/').pop() || '';
   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,
+    };
+  }
 }