coomer-downloader 3.2.0 → 3.3.2

package/src/{utils → services}/file.ts

@@ -1,7 +1,8 @@
 import os from 'node:os';
 import path from 'node:path';
 import type { MediaType } from '../types';
-import { filterString, testMediaType } from './filters';
+import { filterString, testMediaType } from '../utils/filters';
+import { getFileSize } from '../utils/io';
 
 interface ICoomerFile {
   name: string;
@@ -13,18 +14,23 @@ interface ICoomerFile {
 }
 
 export class CoomerFile {
-  public state: 'downloading' | 'pause' = 'pause';
+  public active = false;
 
   constructor(
     public name: string,
     public url: string,
     public filepath?: string,
     public size?: number,
-    public downloaded?: number,
+    public downloaded = 0,
     public content?: string,
   ) {}
 
-  get textContent() {
+  public async getDownloadedSize() {
+    this.downloaded = await getFileSize(this.filepath as string);
+    return this;
+  }
+
+  public get textContent() {
     const text = `${this.name || ''} ${this.content || ''}`.toLowerCase();
     return text;
   }
@@ -72,4 +78,18 @@ export class CoomerFileList {
     this.files = this.files.slice(n);
     return this;
   }
+
+  public async calculateFileSizes() {
+    for (const file of this.files) {
+      await file.getDownloadedSize();
+    }
+  }
+
+  public getActiveFiles() {
+    return this.files.filter((f) => f.active);
+  }
+
+  public getDownloaded() {
+    return this.files.filter((f) => f.size && f.size <= f.downloaded);
+  }
 }

package/src/types/index.ts

@@ -1 +1,15 @@
 export type MediaType = 'video' | 'image' | 'all';
+
+export type DownloaderSubjectSignal =
+  | 'FILES_DOWNLOADING_START'
+  | 'FILES_DOWNLOADING_END'
+  | 'FILE_DOWNLOADING_START'
+  | 'FILE_DOWNLOADING_END'
+  | 'FILE_SKIP'
+  | 'CHUNK_DOWNLOADING_START'
+  | 'CHUNK_DOWNLOADING_UPDATE'
+  | 'CHUNK_DOWNLOADING_END';
+
+export type DownloaderSubject = {
+  type: DownloaderSubjectSignal;
+};

package/src/utils/promise.ts

@@ -1,53 +1,3 @@
 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

@@ -29,8 +29,8 @@ export function fetchWithGlobalHeader(url: string) {
   return fetch(url, { headers: requestHeaders });
 }
 
-export function fetchByteRange(url: string, downloadedSize: number) {
+export function fetchByteRange(url: string, downloadedSize: number, signal?: AbortSignal) {
   const requestHeaders = new Headers(HeadersDefault);
   requestHeaders.set('Range', `bytes=${downloadedSize}-`);
-  return fetch(url, { headers: requestHeaders });
+  return fetch(url, { headers: requestHeaders, signal });
 }

package/src/utils/strings.ts

@@ -1,12 +1,3 @@
 export function b2mb(bytes: number) {
-  return Number.parseFloat((bytes / 1048576).toFixed(2));
-}
-
-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, ' ');
-  return result;
+  return (bytes / 1048576).toFixed(2);
 }

package/src/utils/timer.ts

@@ -1,5 +1,7 @@
+import type { Subject } from 'rxjs';
+
 export class Timer {
-  private timer: NodeJS.Timeout | undefined = undefined;
+  private timer: NodeJS.Timeout | undefined;
 
   constructor(
     private timeout = 10_000,
@@ -30,18 +32,17 @@ export class Timer {
     return this;
   }
 
-  static withSignal(timeout?: number, message?: string) {
-    const controller = new AbortController();
-
+  static withAbortController(
+    timeout: number,
+    abortControllerSubject: Subject<string>,
+    message: string = 'Timeout',
+  ) {
     const callback = () => {
-      controller.abort(message);
+      abortControllerSubject.next(message);
     };
 
     const timer = new Timer(timeout, callback).start();
 
-    return {
-      timer,
-      signal: controller.signal,
-    };
+    return { timer };
   }
 }

package/tsconfig.json

@@ -1,5 +1,6 @@
 {
   "compilerOptions": {
+    "jsx": "react",
     "target": "ESNext",
     "useDefineForClassFields": true,
     "module": "esnext",
@@ -9,7 +10,7 @@
     "moduleResolution": "bundler",
     "isolatedModules": true,
     "moduleDetection": "force",
-    
+
     "declaration": true,
     "typeRoots": ["./dist/index.d.ts", "./src/types", "./node_modules/@types"],
     "outDir": "./dist",

package/src/utils/downloader.ts

@@ -1,108 +0,0 @@
-import fs from 'node:fs';
-import { Readable, Transform } from 'node:stream';
-import { pipeline } from 'node:stream/promises';
-import { Subject } from 'rxjs';
-import { tryFixCoomerUrl } from '../api/coomer-api';
-import type { CoomerFile, CoomerFileList } from './file';
-import { getFileSize, mkdir } from './io';
-import { PromiseRetry } from './promise';
-import { fetchByteRange } from './requests';
-import { Timer } from './timer';
-
-type DownloaderSubject = {
-  type: string;
-  file?: CoomerFile;
-  filesCount?: number;
-};
-
-export class Downloader {
-  public subject = new Subject<DownloaderSubject>();
-
-  constructor(
-    public chunkTimeout = 30_000,
-    public chunkFetchRetries = 5,
-    public fetchRetries = 7,
-  ) {}
-
-  async fetchStream(file: CoomerFile, stream: Readable): Promise<void> {
-    const { subject, chunkTimeout } = this;
-    const { timer, signal } = Timer.withSignal(chunkTimeout, 'chunkTimeout');
-
-    const fileStream = fs.createWriteStream(file.filepath as string, { flags: 'a' });
-
-    const progressStream = new Transform({
-      transform(chunk, _encoding, callback) {
-        this.push(chunk);
-        file.downloaded += chunk.length;
-        timer.reset();
-        subject.next({ type: 'CHUNK_DOWNLOADING_UPDATE', file });
-        callback();
-      },
-    });
-
-    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 });
-    }
-  }
-
-  async downloadFile(file: CoomerFile): Promise<void> {
-    file.downloaded = await getFileSize(file.filepath as string);
-
-    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') as string;
-
-    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: this.chunkFetchRetries,
-        callback: () => {
-          if (sizeOld !== file.downloaded) {
-            return { newRetries: 5 };
-          }
-        },
-      }).execute(async () => await this.fetchStream(file, stream));
-    }
-
-    this.subject.next({ type: 'FILE_DOWNLOADING_END' });
-  }
-
-  async downloadFiles(filelist: CoomerFileList): Promise<void> {
-    mkdir(filelist.dirPath as string);
-
-    this.subject.next({ type: 'FILES_DOWNLOADING_START', filesCount: filelist.files.length });
-
-    for (const file of filelist.files) {
-      this.subject.next({ type: 'FILE_DOWNLOADING_START' });
-
-      await PromiseRetry.create({
-        retries: this.fetchRetries,
-        callback: (retries) => {
-          if (/coomer|kemono/.test(file.url)) {
-            file.url = tryFixCoomerUrl(file.url, retries);
-          }
-        },
-      }).execute(async () => await this.downloadFile(file));
-
-      this.subject.next({ type: 'FILE_DOWNLOADING_END' });
-    }
-
-    this.subject.next({ type: 'FILES_DOWNLOADING_END' });
-  }
-}

package/src/utils/index.ts

@@ -1,11 +0,0 @@
-export { Downloader } from './downloader';
-export { isImage, isVideo, testMediaType } from './filters';
-export { getFileSize, mkdir } from './io';
-export { createMultibar } from './multibar';
-export {
-  fetchByteRange,
-  fetchWithGlobalHeader,
-  HeadersDefault,
-  setGlobalHeaders,
-} from './requests';
-export { b2mb } from './strings';

package/src/utils/multibar.ts

@@ -1,62 +0,0 @@
-import { MultiBar, type Options, type SingleBar } from 'cli-progress';
-import type { Downloader } from './downloader';
-import { b2mb, formatNameStdout } from './strings';
-
-const config: Options = {
-  clearOnComplete: true,
-  gracefulExit: true,
-  autopadding: true,
-  hideCursor: true,
-  format: '{percentage}% | {filename} | {value}/{total}{size}',
-};
-
-export function createMultibar(downloader: Downloader) {
-  const multibar = new MultiBar(config);
-  let bar: SingleBar;
-  let minibar: SingleBar;
-  let filename: string;
-  let index = 0;
-
-  downloader.subject.subscribe({
-    next: ({ type, filesCount, file }) => {
-      switch (type) {
-        case 'FILES_DOWNLOADING_START':
-          bar?.stop();
-          bar = multibar.create(filesCount as number, 0);
-          break;
-
-        case 'FILES_DOWNLOADING_END':
-          bar?.stop();
-          break;
-
-        case 'FILE_DOWNLOADING_START':
-          bar?.update(++index, { filename: 'Downloaded files', size: '' });
-          break;
-
-        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 'CHUNK_DOWNLOADING_UPDATE':
-          minibar?.update(b2mb(file?.downloaded as number), {
-            filename: filename as string,
-            size: 'mb',
-          });
-          break;
-
-        case 'CHUNK_DOWNLOADING_END':
-          multibar?.remove(minibar);
-          break;
-
-        default:
-          break;
-      }
-    },
-  });
-}